Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'staging-6.17-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging
Pull staging updates from Greg KH:
"Here is the "big" set of staging driver changes for 6.17-rc1. That's
in quotes as it really isn't all that big of a set of changes this
development cycle at all.
Major things that stand out are:
- gpib cleanups and tweaks with the majority of the big issues now
taken care of. Odds are it will move out of staging/ in the next
merge window if all goes well.
- more constant cleanups and layer removals from the rtl8723bs
driver. It's amazing how many layers deep they really are, all
cleanups here are great to see
- axis-fifo sysfs api removed and debugfs api added. The sysfs api
didn't work at all so obviously no one was using it. Add the same
information into debugfs as that's the proper place for it, and
make it actually work.
- Remaining changes is lots of small checkpatch cleanups, most of
which seem to have come from a Debconf session where people were
encouraged to submit their first kernel patch, a nice thing to see
happen again.
All of these have been in linux-next with no reported issues"
* tag 'staging-6.17-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (71 commits)
staging: rtl8723bs: remove redundant semicolon in basic_types.h
staging: gpib: Add init response codes for new ni-usb-hs+
staging: rtl8723bs: DoIQK_8723B is empty
staging: rtl8723bs: dm_CheckStatistics is empty
staging: rtl8723bs: hw_var_port_switch is empty
staging: rtl8723bs: _InitOtherVariable is empty
staging: rtl8723bs: rtw_get_encrypt_decrypt_from_registrypriv is empty
staging: rtl8723bs: rtl8723b_set_FwAoacRsvdPage_cmd is empty
staging: rtl8723bs: CheckFwRsvdPageContent is empty
staging: rtl8723bs: clean up redundant & parentheses
staging: axis-fifo: add debugfs interface for dumping fifo registers
staging: axis-fifo: remove sysfs interface
staging: nvec: Fix incorrect null termination of battery manufacturer
staging: gpib: fix typo
staging: sm750fb: fix CamelCase variable naming
staging: vme_user: fix spelling errors
staging: rtl8723bs: remove unnecessary braces in rtl8723b_cmd
staging: rtl8723bs: remove unnecessary commented code
staging: rtl8723bs: add missing blank line after declaration
staging: rtl8723bs: remove unnecessary comment separator lines
...
+426
-925
+42
-173
drivers/staging/axis-fifo/axis-fifo.c
+42
-173
drivers/staging/axis-fifo/axis-fifo.c
···
33
33
#include <linux/uaccess.h>
34
34
#include <linux/jiffies.h>
35
35
#include <linux/miscdevice.h>
36
+
#include <linux/debugfs.h>
36
37
37
38
/* ----------------------------
38
39
* driver parameters
···
44
43
45
44
#define READ_BUF_SIZE 128U /* read buffer length in words */
46
45
#define WRITE_BUF_SIZE 128U /* write buffer length in words */
46
+
47
+
#define AXIS_FIFO_DEBUG_REG_NAME_MAX_LEN 4
47
48
48
49
/* ----------------------------
49
50
* IP register offsets
···
140
137
141
138
struct device *dt_device; /* device created from the device tree */
142
139
struct miscdevice miscdev;
140
+
141
+
struct dentry *debugfs_dir;
143
142
};
144
143
145
-
/* ----------------------------
146
-
* sysfs entries
147
-
* ----------------------------
148
-
*/
149
-
150
-
static ssize_t sysfs_write(struct device *dev, const char *buf,
151
-
size_t count, unsigned int addr_offset)
152
-
{
153
-
struct axis_fifo *fifo = dev_get_drvdata(dev);
154
-
unsigned long tmp;
155
-
int rc;
156
-
157
-
rc = kstrtoul(buf, 0, &tmp);
158
-
if (rc < 0)
159
-
return rc;
160
-
161
-
iowrite32(tmp, fifo->base_addr + addr_offset);
162
-
163
-
return count;
164
-
}
165
-
166
-
static ssize_t sysfs_read(struct device *dev, char *buf,
167
-
unsigned int addr_offset)
168
-
{
169
-
struct axis_fifo *fifo = dev_get_drvdata(dev);
170
-
unsigned int read_val;
171
-
172
-
read_val = ioread32(fifo->base_addr + addr_offset);
173
-
return sysfs_emit(buf, "0x%x\n", read_val);
174
-
}
175
-
176
-
static ssize_t isr_store(struct device *dev, struct device_attribute *attr,
177
-
const char *buf, size_t count)
178
-
{
179
-
return sysfs_write(dev, buf, count, XLLF_ISR_OFFSET);
180
-
}
181
-
182
-
static ssize_t isr_show(struct device *dev,
183
-
struct device_attribute *attr, char *buf)
184
-
{
185
-
return sysfs_read(dev, buf, XLLF_ISR_OFFSET);
186
-
}
187
-
188
-
static DEVICE_ATTR_RW(isr);
189
-
190
-
static ssize_t ier_store(struct device *dev, struct device_attribute *attr,
191
-
const char *buf, size_t count)
192
-
{
193
-
return sysfs_write(dev, buf, count, XLLF_IER_OFFSET);
194
-
}
195
-
196
-
static ssize_t ier_show(struct device *dev,
197
-
struct device_attribute *attr, char *buf)
198
-
{
199
-
return sysfs_read(dev, buf, XLLF_IER_OFFSET);
200
-
}
201
-
202
-
static DEVICE_ATTR_RW(ier);
203
-
204
-
static ssize_t tdfr_store(struct device *dev, struct device_attribute *attr,
205
-
const char *buf, size_t count)
206
-
{
207
-
return sysfs_write(dev, buf, count, XLLF_TDFR_OFFSET);
208
-
}
209
-
210
-
static DEVICE_ATTR_WO(tdfr);
211
-
212
-
static ssize_t tdfv_show(struct device *dev,
213
-
struct device_attribute *attr, char *buf)
214
-
{
215
-
return sysfs_read(dev, buf, XLLF_TDFV_OFFSET);
216
-
}
217
-
218
-
static DEVICE_ATTR_RO(tdfv);
219
-
220
-
static ssize_t tdfd_store(struct device *dev, struct device_attribute *attr,
221
-
const char *buf, size_t count)
222
-
{
223
-
return sysfs_write(dev, buf, count, XLLF_TDFD_OFFSET);
224
-
}
225
-
226
-
static DEVICE_ATTR_WO(tdfd);
227
-
228
-
static ssize_t tlr_store(struct device *dev, struct device_attribute *attr,
229
-
const char *buf, size_t count)
230
-
{
231
-
return sysfs_write(dev, buf, count, XLLF_TLR_OFFSET);
232
-
}
233
-
234
-
static DEVICE_ATTR_WO(tlr);
235
-
236
-
static ssize_t rdfr_store(struct device *dev, struct device_attribute *attr,
237
-
const char *buf, size_t count)
238
-
{
239
-
return sysfs_write(dev, buf, count, XLLF_RDFR_OFFSET);
240
-
}
241
-
242
-
static DEVICE_ATTR_WO(rdfr);
243
-
244
-
static ssize_t rdfo_show(struct device *dev,
245
-
struct device_attribute *attr, char *buf)
246
-
{
247
-
return sysfs_read(dev, buf, XLLF_RDFO_OFFSET);
248
-
}
249
-
250
-
static DEVICE_ATTR_RO(rdfo);
251
-
252
-
static ssize_t rdfd_show(struct device *dev,
253
-
struct device_attribute *attr, char *buf)
254
-
{
255
-
return sysfs_read(dev, buf, XLLF_RDFD_OFFSET);
256
-
}
257
-
258
-
static DEVICE_ATTR_RO(rdfd);
259
-
260
-
static ssize_t rlr_show(struct device *dev,
261
-
struct device_attribute *attr, char *buf)
262
-
{
263
-
return sysfs_read(dev, buf, XLLF_RLR_OFFSET);
264
-
}
265
-
266
-
static DEVICE_ATTR_RO(rlr);
267
-
268
-
static ssize_t srr_store(struct device *dev, struct device_attribute *attr,
269
-
const char *buf, size_t count)
270
-
{
271
-
return sysfs_write(dev, buf, count, XLLF_SRR_OFFSET);
272
-
}
273
-
274
-
static DEVICE_ATTR_WO(srr);
275
-
276
-
static ssize_t tdr_store(struct device *dev, struct device_attribute *attr,
277
-
const char *buf, size_t count)
278
-
{
279
-
return sysfs_write(dev, buf, count, XLLF_TDR_OFFSET);
280
-
}
281
-
282
-
static DEVICE_ATTR_WO(tdr);
283
-
284
-
static ssize_t rdr_show(struct device *dev,
285
-
struct device_attribute *attr, char *buf)
286
-
{
287
-
return sysfs_read(dev, buf, XLLF_RDR_OFFSET);
288
-
}
289
-
290
-
static DEVICE_ATTR_RO(rdr);
291
-
292
-
static struct attribute *axis_fifo_attrs[] = {
293
-
&dev_attr_isr.attr,
294
-
&dev_attr_ier.attr,
295
-
&dev_attr_tdfr.attr,
296
-
&dev_attr_tdfv.attr,
297
-
&dev_attr_tdfd.attr,
298
-
&dev_attr_tlr.attr,
299
-
&dev_attr_rdfr.attr,
300
-
&dev_attr_rdfo.attr,
301
-
&dev_attr_rdfd.attr,
302
-
&dev_attr_rlr.attr,
303
-
&dev_attr_srr.attr,
304
-
&dev_attr_tdr.attr,
305
-
&dev_attr_rdr.attr,
306
-
NULL,
307
-
};
308
-
309
-
static const struct attribute_group axis_fifo_attrs_group = {
310
-
.name = "ip_registers",
311
-
.attrs = axis_fifo_attrs,
312
-
};
313
-
314
-
static const struct attribute_group *axis_fifo_attrs_groups[] = {
315
-
&axis_fifo_attrs_group,
316
-
NULL,
144
+
struct axis_fifo_debug_reg {
145
+
const char * const name;
146
+
unsigned int offset;
317
147
};
318
148
319
149
/* ----------------------------
···
547
711
.write = axis_fifo_write
548
712
};
549
713
714
+
static int axis_fifo_debugfs_regs_show(struct seq_file *m, void *p)
715
+
{
716
+
static const struct axis_fifo_debug_reg regs[] = {
717
+
{"isr", XLLF_ISR_OFFSET},
718
+
{"ier", XLLF_IER_OFFSET},
719
+
{"tdfv", XLLF_TDFV_OFFSET},
720
+
{"rdfo", XLLF_RDFO_OFFSET},
721
+
{ /* Sentinel */ },
722
+
};
723
+
const struct axis_fifo_debug_reg *reg;
724
+
struct axis_fifo *fifo = m->private;
725
+
726
+
for (reg = regs; reg->name; ++reg) {
727
+
u32 val = ioread32(fifo->base_addr + reg->offset);
728
+
729
+
seq_printf(m, "%*s: 0x%08x\n", AXIS_FIFO_DEBUG_REG_NAME_MAX_LEN,
730
+
reg->name, val);
731
+
}
732
+
733
+
return 0;
734
+
}
735
+
DEFINE_SHOW_ATTRIBUTE(axis_fifo_debugfs_regs);
736
+
737
+
static void axis_fifo_debugfs_init(struct axis_fifo *fifo)
738
+
{
739
+
fifo->debugfs_dir = debugfs_create_dir(dev_name(fifo->dt_device), NULL);
740
+
741
+
debugfs_create_file("regs", 0444, fifo->debugfs_dir, fifo,
742
+
&axis_fifo_debugfs_regs_fops);
743
+
}
744
+
550
745
/* read named property from the device tree */
551
746
static int get_dts_property(struct axis_fifo *fifo,
552
747
char *name, unsigned int *var)
···
744
877
fifo->miscdev.fops = &fops;
745
878
fifo->miscdev.minor = MISC_DYNAMIC_MINOR;
746
879
fifo->miscdev.name = device_name;
747
-
fifo->miscdev.groups = axis_fifo_attrs_groups;
748
880
fifo->miscdev.parent = dev;
749
881
rc = misc_register(&fifo->miscdev);
750
882
if (rc < 0)
751
883
goto err_initial;
884
+
885
+
axis_fifo_debugfs_init(fifo);
752
886
753
887
return 0;
754
888
···
763
895
struct device *dev = &pdev->dev;
764
896
struct axis_fifo *fifo = dev_get_drvdata(dev);
765
897
898
+
debugfs_remove(fifo->debugfs_dir);
766
899
misc_deregister(&fifo->miscdev);
767
900
dev_set_drvdata(dev, NULL);
768
901
}
+21
-17
drivers/staging/fbtft/fbtft-core.c
+21
-17
drivers/staging/fbtft/fbtft-core.c
···
568
568
height = display->height;
569
569
}
570
570
571
-
vmem_size = display->width * display->height * bpp / 8;
572
-
vmem = vzalloc(vmem_size);
573
-
if (!vmem)
574
-
goto alloc_fail;
575
-
576
571
fbdefio = devm_kzalloc(dev, sizeof(struct fb_deferred_io), GFP_KERNEL);
577
572
if (!fbdefio)
578
-
goto alloc_fail;
573
+
return NULL;
579
574
580
575
buf = devm_kzalloc(dev, 128, GFP_KERNEL);
581
576
if (!buf)
582
-
goto alloc_fail;
577
+
return NULL;
583
578
584
579
if (display->gamma_num && display->gamma_len) {
585
580
gamma_curves = devm_kcalloc(dev,
···
583
588
sizeof(gamma_curves[0]),
584
589
GFP_KERNEL);
585
590
if (!gamma_curves)
586
-
goto alloc_fail;
591
+
return NULL;
587
592
}
588
593
589
594
info = framebuffer_alloc(sizeof(struct fbtft_par), dev);
590
595
if (!info)
591
-
goto alloc_fail;
596
+
return NULL;
597
+
598
+
vmem_size = display->width * display->height * bpp / 8;
599
+
vmem = vzalloc(vmem_size);
600
+
if (!vmem)
601
+
goto release_framebuf;
592
602
593
603
info->screen_buffer = vmem;
594
604
info->fbops = &fbtft_ops;
···
612
612
info->fix.line_length = width * bpp / 8;
613
613
info->fix.accel = FB_ACCEL_NONE;
614
614
info->fix.smem_len = vmem_size;
615
-
fb_deferred_io_init(info);
615
+
if (fb_deferred_io_init(info))
616
+
goto release_screen_buffer;
616
617
617
618
info->var.rotate = pdata->rotate;
618
619
info->var.xres = width;
···
653
652
if (par->gamma.curves && gamma) {
654
653
if (fbtft_gamma_parse_str(par, par->gamma.curves, gamma,
655
654
strlen(gamma)))
656
-
goto release_framebuf;
655
+
goto cleanup_deferred;
657
656
}
658
657
659
658
/* Transmit buffer */
···
668
667
#endif
669
668
670
669
if (txbuflen > 0) {
671
-
txbuf = devm_kzalloc(par->info->device, txbuflen, GFP_KERNEL);
670
+
txbuf = kzalloc(txbuflen, GFP_KERNEL);
672
671
if (!txbuf)
673
-
goto release_framebuf;
672
+
goto cleanup_deferred;
674
673
par->txbuf.buf = txbuf;
675
674
par->txbuf.len = txbuflen;
676
675
}
···
692
691
693
692
return info;
694
693
694
+
cleanup_deferred:
695
+
fb_deferred_io_cleanup(info);
696
+
release_screen_buffer:
697
+
vfree(info->screen_buffer);
695
698
release_framebuf:
696
699
framebuffer_release(info);
697
-
698
-
alloc_fail:
699
-
vfree(vmem);
700
-
701
700
return NULL;
702
701
}
703
702
EXPORT_SYMBOL(fbtft_framebuffer_alloc);
···
710
709
*/
711
710
void fbtft_framebuffer_release(struct fb_info *info)
712
711
{
712
+
struct fbtft_par *par = info->par;
713
+
714
+
kfree(par->txbuf.buf);
713
715
fb_deferred_io_cleanup(info);
714
716
vfree(info->screen_buffer);
715
717
framebuffer_release(info);
+4
-1
drivers/staging/gpib/TODO
+4
-1
drivers/staging/gpib/TODO
···
1
1
TODO:
2
2
- checkpatch.pl fixes
3
-
- fix device drivers that are broken ("depends on BROKEN" in Kconfig)
3
+
These checks should be ignored:
4
+
CHECK:ALLOC_SIZEOF_STRUCT: Prefer kmalloc(sizeof(*board->private_data)...) over kmalloc(sizeof(struct xxx_priv)...)
5
+
./gpio/gpib_bitbang.c:50: ERROR:COMPLEX_MACRO: Macros with complex values should be enclosed in parenthese
6
+
This warning will be addressed later: WARNING:UNDOCUMENTED_DT_STRING: DT compatible string
4
7
- tidy-up comments:
5
8
- there are some "//comments" and "// comments" scattered around
6
9
- sometimes they are misaligned
+11
-4
drivers/staging/gpib/cb7210/cb7210.c
+11
-4
drivers/staging/gpib/cb7210/cb7210.c
···
1184
1184
static int cb_gpib_probe(struct pcmcia_device *link)
1185
1185
{
1186
1186
struct local_info *info;
1187
-
1188
-
// int ret, i;
1187
+
int ret;
1189
1188
1190
1189
/* Allocate space for private device-specific data */
1191
1190
info = kzalloc(sizeof(*info), GFP_KERNEL);
···
1210
1211
1211
1212
/* Register with Card Services */
1212
1213
curr_dev = link;
1213
-
return cb_gpib_config(link);
1214
-
} /* gpib_attach */
1214
+
ret = cb_gpib_config(link);
1215
+
if (ret)
1216
+
goto free_info;
1217
+
1218
+
return 0;
1219
+
1220
+
free_info:
1221
+
kfree(info);
1222
+
return ret;
1223
+
}
1215
1224
1216
1225
/*
1217
1226
* This deletes a driver "instance". The device is de-registered
+1
-1
drivers/staging/gpib/cec/cec_gpib.c
+1
-1
drivers/staging/gpib/cec/cec_gpib.c
···
302
302
return -EBUSY;
303
303
304
304
cec_priv->plx_iobase = pci_resource_start(cec_priv->pci_device, 1);
305
-
nec_priv->iobase = pci_resource_start(cec_priv->pci_device, 3);
305
+
nec_priv->iobase = pci_resource_start(cec_priv->pci_device, 3);
306
306
307
307
isr_flags |= IRQF_SHARED;
308
308
if (request_irq(cec_priv->pci_device->irq, cec_interrupt, isr_flags, DRV_NAME, board)) {
+2
-2
drivers/staging/gpib/common/gpib_os.c
+2
-2
drivers/staging/gpib/common/gpib_os.c
···
831
831
retval = copy_from_user(&cmd, (void __user *)arg,
832
832
sizeof(struct gpib_board_type_ioctl));
833
833
if (retval)
834
-
return retval;
834
+
return -EFAULT;
835
835
836
836
for (list_ptr = registered_drivers.next; list_ptr != ®istered_drivers;
837
837
list_ptr = list_ptr->next) {
···
1774
1774
1775
1775
static int board_info_ioctl(const struct gpib_board *board, unsigned long arg)
1776
1776
{
1777
-
struct gpib_board_info_ioctl info;
1777
+
struct gpib_board_info_ioctl info = { };
1778
1778
int retval;
1779
1779
1780
1780
info.pad = board->pad;
+1
-1
drivers/staging/gpib/gpio/gpib_bitbang.c
+1
-1
drivers/staging/gpib/gpio/gpib_bitbang.c
···
169
169
#define TE all_descriptors[18]
170
170
#define ACT_LED all_descriptors[19]
171
171
172
-
/* YOGA dapter uses a global enable for the buffer chips, re-using the TE pin */
172
+
/* YOGA adapter uses a global enable for the buffer chips, re-using the TE pin */
173
173
#define YOGA_ENABLE TE
174
174
175
175
static int gpios_vector[] = {
+2
-8
drivers/staging/gpib/hp_82341/hp_82341.c
+2
-8
drivers/staging/gpib/hp_82341/hp_82341.c
···
79
79
int j;
80
80
int count;
81
81
82
-
if (num_fifo_bytes - i < hp_82341_fifo_size)
83
-
block_size = num_fifo_bytes - i;
84
-
else
85
-
block_size = hp_82341_fifo_size;
82
+
block_size = min(num_fifo_bytes - i, hp_82341_fifo_size);
86
83
set_transfer_counter(hp_priv, block_size);
87
84
outb(ENABLE_TI_BUFFER_BIT | DIRECTION_GPIB_TO_HOST_BIT, hp_priv->iobase[3] +
88
85
BUFFER_CONTROL_REG);
···
192
195
for (i = 0; i < fifo_xfer_len;) {
193
196
int block_size;
194
197
195
-
if (fifo_xfer_len - i < hp_82341_fifo_size)
196
-
block_size = fifo_xfer_len - i;
197
-
else
198
-
block_size = hp_82341_fifo_size;
198
+
block_size = min(fifo_xfer_len - i, hp_82341_fifo_size);
199
199
set_transfer_counter(hp_priv, block_size);
200
200
// load data into board's fifo
201
201
for (j = 0; j < block_size;) {
+1
drivers/staging/gpib/include/gpibP.h
+1
drivers/staging/gpib/include/gpibP.h
+112
drivers/staging/gpib/include/gpib_cmd.h
+112
drivers/staging/gpib/include/gpib_cmd.h
···
1
+
/* SPDX-License-Identifier: GPL-2.0 */
2
+
3
+
#ifndef _GPIB_CMD_H
4
+
#define _GPIB_CMD_H
5
+
6
+
#include <linux/types.h>
7
+
8
+
/* Command byte definitions tests and functions */
9
+
10
+
/* mask of bits that actually matter in a command byte */
11
+
enum {
12
+
gpib_command_mask = 0x7f,
13
+
};
14
+
15
+
/* Possible GPIB command messages */
16
+
17
+
enum cmd_byte {
18
+
GTL = 0x1, /* go to local */
19
+
SDC = 0x4, /* selected device clear */
20
+
PP_CONFIG = 0x5,
21
+
GET = 0x8, /* group execute trigger */
22
+
TCT = 0x9, /* take control */
23
+
LLO = 0x11, /* local lockout */
24
+
DCL = 0x14, /* device clear */
25
+
PPU = 0x15, /* parallel poll unconfigure */
26
+
SPE = 0x18, /* serial poll enable */
27
+
SPD = 0x19, /* serial poll disable */
28
+
CFE = 0x1f, /* configure enable */
29
+
LAD = 0x20, /* value to be 'ored' in to obtain listen address */
30
+
UNL = 0x3F, /* unlisten */
31
+
TAD = 0x40, /* value to be 'ored' in to obtain talk address */
32
+
UNT = 0x5F, /* untalk */
33
+
SAD = 0x60, /* my secondary address (base) */
34
+
PPE = 0x60, /* parallel poll enable (base) */
35
+
PPD = 0x70 /* parallel poll disable */
36
+
};
37
+
38
+
/* confine address to range 0 to 30. */
39
+
static inline unsigned int gpib_address_restrict(u32 addr)
40
+
{
41
+
addr &= 0x1f;
42
+
if (addr == 0x1f)
43
+
addr = 0;
44
+
return addr;
45
+
}
46
+
47
+
static inline u8 MLA(u32 addr)
48
+
{
49
+
return gpib_address_restrict(addr) | LAD;
50
+
}
51
+
52
+
static inline u8 MTA(u32 addr)
53
+
{
54
+
return gpib_address_restrict(addr) | TAD;
55
+
}
56
+
57
+
static inline u8 MSA(u32 addr)
58
+
{
59
+
return (addr & 0x1f) | SAD;
60
+
}
61
+
62
+
static inline s32 gpib_address_equal(u32 pad1, s32 sad1, u32 pad2, s32 sad2)
63
+
{
64
+
if (pad1 == pad2) {
65
+
if (sad1 == sad2)
66
+
return 1;
67
+
if (sad1 < 0 && sad2 < 0)
68
+
return 1;
69
+
}
70
+
71
+
return 0;
72
+
}
73
+
74
+
static inline s32 is_PPE(u8 command)
75
+
{
76
+
return (command & 0x70) == 0x60;
77
+
}
78
+
79
+
static inline s32 is_PPD(u8 command)
80
+
{
81
+
return (command & 0x70) == 0x70;
82
+
}
83
+
84
+
static inline s32 in_addressed_command_group(u8 command)
85
+
{
86
+
return (command & 0x70) == 0x0;
87
+
}
88
+
89
+
static inline s32 in_universal_command_group(u8 command)
90
+
{
91
+
return (command & 0x70) == 0x10;
92
+
}
93
+
94
+
static inline s32 in_listen_address_group(u8 command)
95
+
{
96
+
return (command & 0x60) == 0x20;
97
+
}
98
+
99
+
static inline s32 in_talk_address_group(u8 command)
100
+
{
101
+
return (command & 0x60) == 0x40;
102
+
}
103
+
104
+
static inline s32 in_primary_command_group(u8 command)
105
+
{
106
+
return in_addressed_command_group(command) ||
107
+
in_universal_command_group(command) ||
108
+
in_listen_address_group(command) ||
109
+
in_talk_address_group(command);
110
+
}
111
+
112
+
#endif /* _GPIB_CMD_H */
-1
drivers/staging/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c
-1
drivers/staging/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c
+7
-7
drivers/staging/gpib/ni_usb/ni_usb_gpib.c
+7
-7
drivers/staging/gpib/ni_usb/ni_usb_gpib.c
···
2079
2079
}
2080
2080
if (buffer[++j] != 0x0) { // [6]
2081
2081
ready = 1;
2082
-
// NI-USB-HS+ sends 0xf here
2082
+
// NI-USB-HS+ sends 0xf or 0x19 here
2083
2083
if (buffer[j] != 0x2 && buffer[j] != 0xe && buffer[j] != 0xf &&
2084
-
buffer[j] != 0x16) {
2085
-
dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x2, 0xe, 0xf or 0x16\n",
2084
+
buffer[j] != 0x16 && buffer[j] != 0x19) {
2085
+
dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x2, 0xe, 0xf, 0x16 or 0x19\n",
2086
2086
j, (int)buffer[j]);
2087
2087
unexpected = 1;
2088
2088
}
···
2110
2110
j, (int)buffer[j]);
2111
2111
unexpected = 1;
2112
2112
}
2113
-
if (buffer[++j] != 0x0) {
2113
+
if (buffer[++j] != 0x0) { // [10] MC usb-488 sends 0x7 here, new HS+ sends 0x59
2114
2114
ready = 1;
2115
-
if (buffer[j] != 0x96 && buffer[j] != 0x7 && buffer[j] != 0x6e) {
2116
-
// [10] MC usb-488 sends 0x7 here
2117
-
dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x96, 0x07 or 0x6e\n",
2115
+
if (buffer[j] != 0x96 && buffer[j] != 0x7 && buffer[j] != 0x6e &&
2116
+
buffer[j] != 0x59) {
2117
+
dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x96, 0x07, 0x6e or 0x59\n",
2118
2118
j, (int)buffer[j]);
2119
2119
unexpected = 1;
2120
2120
}
-198
drivers/staging/gpib/uapi/gpib.h
-198
drivers/staging/gpib/uapi/gpib.h
···
83
83
BUS_EOI = 0x8000 /* EOI line status bit */
84
84
};
85
85
86
-
/* Possible GPIB command messages */
87
-
88
-
enum cmd_byte {
89
-
GTL = 0x1, /* go to local */
90
-
SDC = 0x4, /* selected device clear */
91
-
PP_CONFIG = 0x5,
92
-
#ifndef PPC
93
-
PPC = PP_CONFIG, /* parallel poll configure */
94
-
#endif
95
-
GET = 0x8, /* group execute trigger */
96
-
TCT = 0x9, /* take control */
97
-
LLO = 0x11, /* local lockout */
98
-
DCL = 0x14, /* device clear */
99
-
PPU = 0x15, /* parallel poll unconfigure */
100
-
SPE = 0x18, /* serial poll enable */
101
-
SPD = 0x19, /* serial poll disable */
102
-
CFE = 0x1f, /* configure enable */
103
-
LAD = 0x20, /* value to be 'ored' in to obtain listen address */
104
-
UNL = 0x3F, /* unlisten */
105
-
TAD = 0x40, /* value to be 'ored' in to obtain talk address */
106
-
UNT = 0x5F, /* untalk */
107
-
SAD = 0x60, /* my secondary address (base) */
108
-
PPE = 0x60, /* parallel poll enable (base) */
109
-
PPD = 0x70 /* parallel poll disable */
110
-
};
111
-
112
86
enum ppe_bits {
113
87
PPC_DISABLE = 0x10,
114
88
PPC_SENSE = 0x8, /* parallel poll sense bit */
115
89
PPC_DIO_MASK = 0x7
116
-
};
117
-
118
-
/* confine address to range 0 to 30. */
119
-
static inline unsigned int gpib_address_restrict(unsigned int addr)
120
-
{
121
-
addr &= 0x1f;
122
-
if (addr == 0x1f)
123
-
addr = 0;
124
-
return addr;
125
-
}
126
-
127
-
static inline __u8 MLA(unsigned int addr)
128
-
{
129
-
return gpib_address_restrict(addr) | LAD;
130
-
}
131
-
132
-
static inline __u8 MTA(unsigned int addr)
133
-
{
134
-
return gpib_address_restrict(addr) | TAD;
135
-
}
136
-
137
-
static inline __u8 MSA(unsigned int addr)
138
-
{
139
-
return (addr & 0x1f) | SAD;
140
-
}
141
-
142
-
static inline __u8 PPE_byte(unsigned int dio_line, int sense)
143
-
{
144
-
__u8 cmd;
145
-
146
-
cmd = PPE;
147
-
if (sense)
148
-
cmd |= PPC_SENSE;
149
-
cmd |= (dio_line - 1) & 0x7;
150
-
return cmd;
151
-
}
152
-
153
-
/* mask of bits that actually matter in a command byte */
154
-
enum {
155
-
gpib_command_mask = 0x7f,
156
-
};
157
-
158
-
static inline int is_PPE(__u8 command)
159
-
{
160
-
return (command & 0x70) == 0x60;
161
-
}
162
-
163
-
static inline int is_PPD(__u8 command)
164
-
{
165
-
return (command & 0x70) == 0x70;
166
-
}
167
-
168
-
static inline int in_addressed_command_group(__u8 command)
169
-
{
170
-
return (command & 0x70) == 0x0;
171
-
}
172
-
173
-
static inline int in_universal_command_group(__u8 command)
174
-
{
175
-
return (command & 0x70) == 0x10;
176
-
}
177
-
178
-
static inline int in_listen_address_group(__u8 command)
179
-
{
180
-
return (command & 0x60) == 0x20;
181
-
}
182
-
183
-
static inline int in_talk_address_group(__u8 command)
184
-
{
185
-
return (command & 0x60) == 0x40;
186
-
}
187
-
188
-
static inline int in_primary_command_group(__u8 command)
189
-
{
190
-
return in_addressed_command_group(command) ||
191
-
in_universal_command_group(command) ||
192
-
in_listen_address_group(command) ||
193
-
in_talk_address_group(command);
194
-
}
195
-
196
-
static inline int gpib_address_equal(unsigned int pad1, int sad1, unsigned int pad2, int sad2)
197
-
{
198
-
if (pad1 == pad2) {
199
-
if (sad1 == sad2)
200
-
return 1;
201
-
if (sad1 < 0 && sad2 < 0)
202
-
return 1;
203
-
}
204
-
205
-
return 0;
206
-
}
207
-
208
-
enum ibask_option {
209
-
IBA_PAD = 0x1,
210
-
IBA_SAD = 0x2,
211
-
IBA_TMO = 0x3,
212
-
IBA_EOT = 0x4,
213
-
IBA_PPC = 0x5, /* board only */
214
-
IBA_READ_DR = 0x6, /* device only */
215
-
IBA_AUTOPOLL = 0x7, /* board only */
216
-
IBA_CICPROT = 0x8, /* board only */
217
-
IBA_IRQ = 0x9, /* board only */
218
-
IBA_SC = 0xa, /* board only */
219
-
IBA_SRE = 0xb, /* board only */
220
-
IBA_EOS_RD = 0xc,
221
-
IBA_EOS_WRT = 0xd,
222
-
IBA_EOS_CMP = 0xe,
223
-
IBA_EOS_CHAR = 0xf,
224
-
IBA_PP2 = 0x10, /* board only */
225
-
IBA_TIMING = 0x11, /* board only */
226
-
IBA_DMA = 0x12, /* board only */
227
-
IBA_READ_ADJUST = 0x13,
228
-
IBA_WRITE_ADJUST = 0x14,
229
-
IBA_EVENT_QUEUE = 0x15, /* board only */
230
-
IBA_SPOLL_BIT = 0x16, /* board only */
231
-
IBA_SEND_LLO = 0x17, /* board only */
232
-
IBA_SPOLL_TIME = 0x18, /* device only */
233
-
IBA_PPOLL_TIME = 0x19, /* board only */
234
-
IBA_END_BIT_IS_NORMAL = 0x1a,
235
-
IBA_UN_ADDR = 0x1b, /* device only */
236
-
IBA_HS_CABLE_LENGTH = 0x1f, /* board only */
237
-
IBA_IST = 0x20, /* board only */
238
-
IBA_RSV = 0x21, /* board only */
239
-
IBA_BNA = 0x200, /* device only */
240
-
/* linux-gpib extensions */
241
-
IBA_7_BIT_EOS = 0x1000 /* board only. Returns 1 if board supports 7 bit eos compares*/
242
-
};
243
-
244
-
enum ibconfig_option {
245
-
IBC_PAD = 0x1,
246
-
IBC_SAD = 0x2,
247
-
IBC_TMO = 0x3,
248
-
IBC_EOT = 0x4,
249
-
IBC_PPC = 0x5, /* board only */
250
-
IBC_READDR = 0x6, /* device only */
251
-
IBC_AUTOPOLL = 0x7, /* board only */
252
-
IBC_CICPROT = 0x8, /* board only */
253
-
IBC_IRQ = 0x9, /* board only */
254
-
IBC_SC = 0xa, /* board only */
255
-
IBC_SRE = 0xb, /* board only */
256
-
IBC_EOS_RD = 0xc,
257
-
IBC_EOS_WRT = 0xd,
258
-
IBC_EOS_CMP = 0xe,
259
-
IBC_EOS_CHAR = 0xf,
260
-
IBC_PP2 = 0x10, /* board only */
261
-
IBC_TIMING = 0x11, /* board only */
262
-
IBC_DMA = 0x12, /* board only */
263
-
IBC_READ_ADJUST = 0x13,
264
-
IBC_WRITE_ADJUST = 0x14,
265
-
IBC_EVENT_QUEUE = 0x15, /* board only */
266
-
IBC_SPOLL_BIT = 0x16, /* board only */
267
-
IBC_SEND_LLO = 0x17, /* board only */
268
-
IBC_SPOLL_TIME = 0x18, /* device only */
269
-
IBC_PPOLL_TIME = 0x19, /* board only */
270
-
IBC_END_BIT_IS_NORMAL = 0x1a,
271
-
IBC_UN_ADDR = 0x1b, /* device only */
272
-
IBC_HS_CABLE_LENGTH = 0x1f, /* board only */
273
-
IBC_IST = 0x20, /* board only */
274
-
IBC_RSV = 0x21, /* board only */
275
-
IBC_BNA = 0x200 /* device only */
276
-
};
277
-
278
-
enum t1_delays {
279
-
T1_DELAY_2000ns = 1,
280
-
T1_DELAY_500ns = 2,
281
-
T1_DELAY_350ns = 3
282
90
};
283
91
284
92
enum {
···
98
290
EVENT_DEV_TRG = 1,
99
291
EVENT_DEV_CLR = 2,
100
292
EVENT_IFC = 3
101
-
};
102
-
103
-
enum gpib_stb {
104
-
IB_STB_RQS = 0x40, /* IEEE 488.1 & 2 */
105
-
IB_STB_ESB = 0x20, /* IEEE 488.2 only */
106
-
IB_STB_MAV = 0x10 /* IEEE 488.2 only */
107
293
};
108
294
109
295
#endif /* _GPIB_H */
+58
-54
drivers/staging/gpib/uapi/gpib_ioctl.h
+58
-54
drivers/staging/gpib/uapi/gpib_ioctl.h
···
19
19
/* argument for read/write/command ioctls */
20
20
struct gpib_read_write_ioctl {
21
21
__u64 buffer_ptr;
22
-
unsigned int requested_transfer_count;
23
-
unsigned int completed_transfer_count;
24
-
int end; /* end flag return for reads, end io suppression request for cmd*/
25
-
int handle;
22
+
__u32 requested_transfer_count;
23
+
__u32 completed_transfer_count;
24
+
__s32 end; /* end flag return for reads, end io suppression request for cmd*/
25
+
__s32 handle;
26
26
};
27
27
28
28
struct gpib_open_dev_ioctl {
29
-
unsigned int handle;
30
-
unsigned int pad;
31
-
int sad;
32
-
unsigned is_board : 1;
29
+
__u32 handle;
30
+
__u32 pad;
31
+
__s32 sad;
32
+
__u32 is_board;
33
33
};
34
34
35
35
struct gpib_close_dev_ioctl {
36
-
unsigned int handle;
36
+
__u32 handle;
37
37
};
38
38
39
39
struct gpib_serial_poll_ioctl {
40
-
unsigned int pad;
41
-
int sad;
40
+
__u32 pad;
41
+
__s32 sad;
42
42
__u8 status_byte;
43
+
__u8 padding[3]; // align to 32 bit boundary
43
44
};
44
45
45
46
struct gpib_eos_ioctl {
46
-
int eos;
47
-
int eos_flags;
47
+
__s32 eos;
48
+
__s32 eos_flags;
48
49
};
49
50
50
51
struct gpib_wait_ioctl {
51
-
int handle;
52
-
int wait_mask;
53
-
int clear_mask;
54
-
int set_mask;
55
-
int ibsta;
56
-
int pad;
57
-
int sad;
58
-
unsigned int usec_timeout;
52
+
__s32 handle;
53
+
__s32 wait_mask;
54
+
__s32 clear_mask;
55
+
__s32 set_mask;
56
+
__s32 ibsta;
57
+
__s32 pad;
58
+
__s32 sad;
59
+
__u32 usec_timeout;
59
60
};
60
61
61
62
struct gpib_online_ioctl {
62
63
__u64 init_data_ptr;
63
-
int init_data_length;
64
-
int online;
64
+
__s32 init_data_length;
65
+
__s32 online;
65
66
};
66
67
67
68
struct gpib_spoll_bytes_ioctl {
68
-
unsigned int num_bytes;
69
-
unsigned int pad;
70
-
int sad;
69
+
__u32 num_bytes;
70
+
__u32 pad;
71
+
__s32 sad;
71
72
};
72
73
73
74
struct gpib_board_info_ioctl {
74
-
unsigned int pad;
75
-
int sad;
76
-
int parallel_poll_configuration;
77
-
int autopolling;
78
-
int is_system_controller;
79
-
unsigned int t1_delay;
75
+
__u32 pad;
76
+
__s32 sad;
77
+
__s32 parallel_poll_configuration;
78
+
__s32 autopolling;
79
+
__s32 is_system_controller;
80
+
__u32 t1_delay;
80
81
unsigned ist : 1;
81
82
unsigned no_7_bit_eos : 1;
83
+
unsigned padding :30; // align to 32 bit boundary
82
84
};
83
85
84
86
struct gpib_select_pci_ioctl {
85
-
int pci_bus;
86
-
int pci_slot;
87
+
__s32 pci_bus;
88
+
__s32 pci_slot;
87
89
};
88
90
89
91
struct gpib_ppoll_config_ioctl {
90
92
__u8 config;
91
93
unsigned set_ist : 1;
92
94
unsigned clear_ist : 1;
95
+
unsigned padding :22; // align to 32 bit boundary
93
96
};
94
97
95
98
struct gpib_pad_ioctl {
96
-
unsigned int handle;
97
-
unsigned int pad;
99
+
__u32 handle;
100
+
__u32 pad;
98
101
};
99
102
100
103
struct gpib_sad_ioctl {
101
-
unsigned int handle;
102
-
int sad;
104
+
__u32 handle;
105
+
__s32 sad;
103
106
};
104
107
105
108
// select a piece of hardware to attach by its sysfs device path
···
113
110
// update status byte and request service
114
111
struct gpib_request_service2 {
115
112
__u8 status_byte;
116
-
int new_reason_for_service;
113
+
__u8 padding[3]; // align to 32 bit boundary
114
+
__s32 new_reason_for_service;
117
115
};
118
116
119
117
/* Standard functions. */
···
127
123
IBWAIT = _IOWR(GPIB_CODE, 5, struct gpib_wait_ioctl),
128
124
IBRPP = _IOWR(GPIB_CODE, 6, __u8),
129
125
130
-
IBSIC = _IOW(GPIB_CODE, 9, unsigned int),
131
-
IBSRE = _IOW(GPIB_CODE, 10, int),
126
+
IBSIC = _IOW(GPIB_CODE, 9, __u32),
127
+
IBSRE = _IOW(GPIB_CODE, 10, __s32),
132
128
IBGTS = _IO(GPIB_CODE, 11),
133
-
IBCAC = _IOW(GPIB_CODE, 12, int),
134
-
IBLINES = _IOR(GPIB_CODE, 14, short),
129
+
IBCAC = _IOW(GPIB_CODE, 12, __s32),
130
+
IBLINES = _IOR(GPIB_CODE, 14, __s16),
135
131
IBPAD = _IOW(GPIB_CODE, 15, struct gpib_pad_ioctl),
136
132
IBSAD = _IOW(GPIB_CODE, 16, struct gpib_sad_ioctl),
137
-
IBTMO = _IOW(GPIB_CODE, 17, unsigned int),
133
+
IBTMO = _IOW(GPIB_CODE, 17, __u32),
138
134
IBRSP = _IOWR(GPIB_CODE, 18, struct gpib_serial_poll_ioctl),
139
135
IBEOS = _IOW(GPIB_CODE, 19, struct gpib_eos_ioctl),
140
136
IBRSV = _IOW(GPIB_CODE, 20, __u8),
141
137
CFCBASE = _IOW(GPIB_CODE, 21, __u64),
142
-
CFCIRQ = _IOW(GPIB_CODE, 22, unsigned int),
143
-
CFCDMA = _IOW(GPIB_CODE, 23, unsigned int),
138
+
CFCIRQ = _IOW(GPIB_CODE, 22, __u32),
139
+
CFCDMA = _IOW(GPIB_CODE, 23, __u32),
144
140
CFCBOARDTYPE = _IOW(GPIB_CODE, 24, struct gpib_board_type_ioctl),
145
141
146
-
IBMUTEX = _IOW(GPIB_CODE, 26, int),
142
+
IBMUTEX = _IOW(GPIB_CODE, 26, __s32),
147
143
IBSPOLL_BYTES = _IOWR(GPIB_CODE, 27, struct gpib_spoll_bytes_ioctl),
148
144
IBPPC = _IOW(GPIB_CODE, 28, struct gpib_ppoll_config_ioctl),
149
145
IBBOARD_INFO = _IOR(GPIB_CODE, 29, struct gpib_board_info_ioctl),
150
146
151
-
IBQUERY_BOARD_RSV = _IOR(GPIB_CODE, 31, int),
147
+
IBQUERY_BOARD_RSV = _IOR(GPIB_CODE, 31, __s32),
152
148
IBSELECT_PCI = _IOWR(GPIB_CODE, 32, struct gpib_select_pci_ioctl),
153
-
IBEVENT = _IOR(GPIB_CODE, 33, short),
154
-
IBRSC = _IOW(GPIB_CODE, 34, int),
155
-
IB_T1_DELAY = _IOW(GPIB_CODE, 35, unsigned int),
149
+
IBEVENT = _IOR(GPIB_CODE, 33, __s16),
150
+
IBRSC = _IOW(GPIB_CODE, 34, __s32),
151
+
IB_T1_DELAY = _IOW(GPIB_CODE, 35, __u32),
156
152
IBLOC = _IO(GPIB_CODE, 36),
157
153
158
-
IBAUTOSPOLL = _IOW(GPIB_CODE, 38, short),
154
+
IBAUTOSPOLL = _IOW(GPIB_CODE, 38, __s16),
159
155
IBONL = _IOW(GPIB_CODE, 39, struct gpib_online_ioctl),
160
-
IBPP2_SET = _IOW(GPIB_CODE, 40, short),
161
-
IBPP2_GET = _IOR(GPIB_CODE, 41, short),
156
+
IBPP2_SET = _IOW(GPIB_CODE, 40, __s16),
157
+
IBPP2_GET = _IOR(GPIB_CODE, 41, __s16),
162
158
IBSELECT_DEVICE_PATH = _IOW(GPIB_CODE, 43, struct gpib_select_device_path_ioctl),
163
159
// 44 was IBSELECT_SERIAL_NUMBER
164
160
IBRSV2 = _IOW(GPIB_CODE, 45, struct gpib_request_service2)
+14
-14
drivers/staging/greybus/Documentation/firmware/firmware.c
+14
-14
drivers/staging/greybus/Documentation/firmware/firmware.c
···
47
47
ret = ioctl(fd, FW_MGMT_IOC_GET_INTF_FW, &intf_fw_info);
48
48
if (ret < 0) {
49
49
printf("Failed to get interface firmware version: %s (%d)\n",
50
-
fwdev, ret);
50
+
fwdev, ret);
51
51
return -1;
52
52
}
53
53
54
54
printf("Interface Firmware tag (%s), major (%d), minor (%d)\n",
55
-
intf_fw_info.firmware_tag, intf_fw_info.major,
55
+
intf_fw_info.firmware_tag, intf_fw_info.major,
56
56
intf_fw_info.minor);
57
57
58
58
/* Try Interface Firmware load over Unipro */
···
69
69
ret = ioctl(fd, FW_MGMT_IOC_INTF_LOAD_AND_VALIDATE, &intf_load);
70
70
if (ret < 0) {
71
71
printf("Failed to load interface firmware: %s (%d)\n", fwdev,
72
-
ret);
72
+
ret);
73
73
return -1;
74
74
}
75
75
76
76
if (intf_load.status != GB_FW_U_LOAD_STATUS_VALIDATED &&
77
77
intf_load.status != GB_FW_U_LOAD_STATUS_UNVALIDATED) {
78
78
printf("Load status says loading failed: %d\n",
79
-
intf_load.status);
79
+
intf_load.status);
80
80
return -1;
81
81
}
82
82
83
83
printf("Interface Firmware (%s) Load done: major: %d, minor: %d, status: %d\n",
84
-
firmware_tag, intf_load.major, intf_load.minor,
85
-
intf_load.status);
84
+
firmware_tag, intf_load.major, intf_load.minor,
85
+
intf_load.status);
86
86
87
87
/* Initiate Mode-switch to the newly loaded firmware */
88
88
printf("Initiate Mode switch\n");
···
108
108
ret = ioctl(fd, FW_MGMT_IOC_GET_BACKEND_FW, &backend_fw_info);
109
109
if (ret < 0) {
110
110
printf("Failed to get backend firmware version: %s (%d)\n",
111
-
fwdev, ret);
111
+
fwdev, ret);
112
112
return -1;
113
113
}
114
114
115
115
printf("Backend Firmware tag (%s), major (%d), minor (%d), status (%d)\n",
116
-
backend_fw_info.firmware_tag, backend_fw_info.major,
116
+
backend_fw_info.firmware_tag, backend_fw_info.major,
117
117
backend_fw_info.minor, backend_fw_info.status);
118
118
119
119
if (backend_fw_info.status == GB_FW_U_BACKEND_VERSION_STATUS_RETRY)
120
120
goto retry_fw_version;
121
121
122
-
if ((backend_fw_info.status != GB_FW_U_BACKEND_VERSION_STATUS_SUCCESS)
123
-
&& (backend_fw_info.status != GB_FW_U_BACKEND_VERSION_STATUS_NOT_AVAILABLE)) {
122
+
if ((backend_fw_info.status != GB_FW_U_BACKEND_VERSION_STATUS_SUCCESS) &&
123
+
(backend_fw_info.status != GB_FW_U_BACKEND_VERSION_STATUS_NOT_AVAILABLE)) {
124
124
printf("Failed to get backend firmware version: %s (%d)\n",
125
-
fwdev, backend_fw_info.status);
125
+
fwdev, backend_fw_info.status);
126
126
return -1;
127
127
}
128
128
···
148
148
149
149
if (backend_update.status != GB_FW_U_BACKEND_FW_STATUS_SUCCESS) {
150
150
printf("Load status says loading failed: %d\n",
151
-
backend_update.status);
151
+
backend_update.status);
152
152
} else {
153
153
printf("Backend Firmware (%s) Load done: status: %d\n",
154
-
firmware_tag, backend_update.status);
154
+
firmware_tag, backend_update.status);
155
155
}
156
156
157
157
return 0;
···
185
185
fw_timeout = strtoul(argv[4], &endptr, 10);
186
186
187
187
printf("Trying Firmware update: fwdev: %s, type: %s, tag: %s, timeout: %u\n",
188
-
fwdev, fw_update_type == 0 ? "interface" : "backend",
188
+
fwdev, fw_update_type == 0 ? "interface" : "backend",
189
189
firmware_tag, fw_timeout);
190
190
191
191
printf("Opening %s firmware management device\n", fwdev);
+3
-3
drivers/staging/greybus/gbphy.c
+3
-3
drivers/staging/greybus/gbphy.c
···
102
102
}
103
103
104
104
static const struct gbphy_device_id *
105
-
gbphy_dev_match_id(struct gbphy_device *gbphy_dev,
106
-
struct gbphy_driver *gbphy_drv)
105
+
gbphy_dev_match_id(const struct gbphy_device *gbphy_dev,
106
+
const struct gbphy_driver *gbphy_drv)
107
107
{
108
108
const struct gbphy_device_id *id = gbphy_drv->id_table;
109
109
···
119
119
120
120
static int gbphy_dev_match(struct device *dev, const struct device_driver *drv)
121
121
{
122
-
struct gbphy_driver *gbphy_drv = to_gbphy_driver(drv);
122
+
const struct gbphy_driver *gbphy_drv = to_gbphy_driver(drv);
123
123
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
124
124
const struct gbphy_device_id *id;
125
125
-6
drivers/staging/greybus/gpio.c
-6
drivers/staging/greybus/gpio.c
···
192
192
struct gb_gpio_set_value_request request;
193
193
int ret;
194
194
195
-
if (ggc->lines[which].direction == 1) {
196
-
dev_warn(dev, "refusing to set value of input gpio %u\n",
197
-
which);
198
-
return -EPERM;
199
-
}
200
-
201
195
request.which = which;
202
196
request.value = value_high ? 1 : 0;
203
197
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_SET_VALUE,
+7
-7
drivers/staging/greybus/power_supply.c
+7
-7
drivers/staging/greybus/power_supply.c
···
324
324
}
325
325
326
326
static int is_psy_prop_writeable(struct gb_power_supply *gbpsy,
327
-
enum power_supply_property psp)
327
+
enum power_supply_property psp)
328
328
{
329
329
struct gb_power_supply_prop *prop;
330
330
···
493
493
if (!gbpsy->model_name)
494
494
return -ENOMEM;
495
495
gbpsy->serial_number = kstrndup(resp.serial_number, PROP_MAX,
496
-
GFP_KERNEL);
496
+
GFP_KERNEL);
497
497
if (!gbpsy->serial_number)
498
498
return -ENOMEM;
499
499
···
546
546
}
547
547
548
548
gbpsy->props = kcalloc(gbpsy->properties_count, sizeof(*gbpsy->props),
549
-
GFP_KERNEL);
549
+
GFP_KERNEL);
550
550
if (!gbpsy->props) {
551
551
ret = -ENOMEM;
552
552
goto out_put_operation;
···
634
634
}
635
635
636
636
static int __gb_power_supply_property_strval_get(struct gb_power_supply *gbpsy,
637
-
enum power_supply_property psp,
638
-
union power_supply_propval *val)
637
+
enum power_supply_property psp,
638
+
union power_supply_propval *val)
639
639
{
640
640
switch (psp) {
641
641
case POWER_SUPPLY_PROP_MODEL_NAME:
···
943
943
goto out;
944
944
945
945
supplies->supply = kcalloc(supplies->supplies_count,
946
-
sizeof(struct gb_power_supply),
947
-
GFP_KERNEL);
946
+
sizeof(struct gb_power_supply),
947
+
GFP_KERNEL);
948
948
949
949
if (!supplies->supply) {
950
950
ret = -ENOMEM;
+1
-1
drivers/staging/nvec/nvec_power.c
+1
-1
drivers/staging/nvec/nvec_power.c
+2
-7
drivers/staging/rtl8723bs/core/rtw_ap.c
+2
-7
drivers/staging/rtl8723bs/core/rtw_ap.c
···
741
741
if (p && ie_len) {
742
742
pht_info = (struct HT_info_element *)(p + 2);
743
743
744
-
if (cur_channel > 14) {
745
-
if ((pregpriv->bw_mode & 0xf0) > 0)
746
-
cbw40_enable = 1;
747
-
} else {
748
-
if ((pregpriv->bw_mode & 0x0f) > 0)
749
-
cbw40_enable = 1;
750
-
}
744
+
if ((pregpriv->bw_mode & 0x0f) > 0)
745
+
cbw40_enable = 1;
751
746
752
747
if ((cbw40_enable) && (pht_info->infos[0] & BIT(2))) {
753
748
/* switch to the 40M Hz mode */
-3
drivers/staging/rtl8723bs/core/rtw_cmd.c
-3
drivers/staging/rtl8723bs/core/rtw_cmd.c
+7
-18
drivers/staging/rtl8723bs/core/rtw_efuse.c
+7
-18
drivers/staging/rtl8723bs/core/rtw_efuse.c
···
70
70
* When Who Remark
71
71
* 11/17/2008 MHC Create Version 0.
72
72
*
73
-
*---------------------------------------------------------------------------*/
73
+
*/
74
74
void
75
75
Efuse_PowerSwitch(
76
76
struct adapter *padapter,
···
85
85
Efuse_CalculateWordCnts(u8 word_en)
86
86
{
87
87
u8 word_cnts = 0;
88
+
88
89
if (!(word_en & BIT(0)))
89
90
word_cnts++; /* 0 : write enable */
90
91
if (!(word_en & BIT(1)))
···
164
163
* When Who Remark
165
164
* 09/23/2008 MHC Copy from WMAC.
166
165
*
167
-
*---------------------------------------------------------------------------*/
166
+
*/
168
167
u8
169
168
EFUSE_Read1Byte(
170
169
struct adapter *Adapter,
···
287
286
return bResult;
288
287
}
289
288
290
-
u8
291
-
Efuse_WordEnableDataWrite(struct adapter *padapter,
292
-
u16 efuse_addr,
293
-
u8 word_en,
294
-
u8 *data,
295
-
bool bPseudoTest)
296
-
{
297
-
return padapter->HalFunc.Efuse_WordEnableDataWrite(padapter, efuse_addr,
298
-
word_en, data,
299
-
bPseudoTest);
300
-
}
301
-
302
289
/*-----------------------------------------------------------------------------
303
290
* Function: Efuse_ReadAllMap
304
291
*
···
302
313
* When Who Remark
303
314
* 11/11/2008 MHC Create Version 0.
304
315
*
305
-
*---------------------------------------------------------------------------*/
316
+
*/
306
317
void
307
318
Efuse_ReadAllMap(
308
319
struct adapter *padapter,
···
339
350
* When Who Remark
340
351
* 11/12/2008 MHC Create Version 0.
341
352
*
342
-
*---------------------------------------------------------------------------*/
353
+
*/
343
354
static void efuse_ShadowRead1Byte(struct adapter *padapter, u16 Offset, u8 *Value)
344
355
{
345
356
struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
···
385
396
* When Who Remark
386
397
* 11/13/2008 MHC Create Version 0.
387
398
*
388
-
*---------------------------------------------------------------------------*/
399
+
*/
389
400
void EFUSE_ShadowMapUpdate(struct adapter *padapter, u8 efuseType, bool bPseudoTest)
390
401
{
391
402
struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
···
418
429
* When Who Remark
419
430
* 11/12/2008 MHC Create Version 0.
420
431
*
421
-
*---------------------------------------------------------------------------*/
432
+
*/
422
433
void EFUSE_ShadowRead(struct adapter *padapter, u8 Type, u16 Offset, u32 *Value)
423
434
{
424
435
if (Type == 1)
+68
-84
drivers/staging/rtl8723bs/core/rtw_mlme.c
+68
-84
drivers/staging/rtl8723bs/core/rtw_mlme.c
···
119
119
pnetwork = NULL;
120
120
goto exit;
121
121
}
122
-
plist = get_next(&(free_queue->queue));
122
+
plist = get_next(&free_queue->queue);
123
123
124
124
pnetwork = container_of(plist, struct wlan_network, list);
125
125
···
141
141
{
142
142
unsigned int delta_time;
143
143
u32 lifetime = SCANQUEUE_LIFETIME;
144
-
struct __queue *free_queue = &(pmlmepriv->free_bss_pool);
144
+
struct __queue *free_queue = &pmlmepriv->free_bss_pool;
145
145
146
146
if (!pnetwork)
147
147
return;
···
161
161
162
162
spin_lock_bh(&free_queue->lock);
163
163
164
-
list_del_init(&(pnetwork->list));
164
+
list_del_init(&pnetwork->list);
165
165
166
-
list_add_tail(&(pnetwork->list), &(free_queue->queue));
166
+
list_add_tail(&pnetwork->list, &free_queue->queue);
167
167
168
168
spin_unlock_bh(&free_queue->lock);
169
169
}
···
171
171
void _rtw_free_network_nolock(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork)
172
172
{
173
173
174
-
struct __queue *free_queue = &(pmlmepriv->free_bss_pool);
174
+
struct __queue *free_queue = &pmlmepriv->free_bss_pool;
175
175
176
176
if (!pnetwork)
177
177
return;
···
179
179
if (pnetwork->fixed)
180
180
return;
181
181
182
-
list_del_init(&(pnetwork->list));
182
+
list_del_init(&pnetwork->list);
183
183
184
-
list_add_tail(&(pnetwork->list), get_list_head(free_queue));
184
+
list_add_tail(&pnetwork->list, get_list_head(free_queue));
185
185
}
186
186
187
187
/*
···
287
287
void rtw_free_network_nolock(struct adapter *padapter, struct wlan_network *pnetwork);
288
288
void rtw_free_network_nolock(struct adapter *padapter, struct wlan_network *pnetwork)
289
289
{
290
-
_rtw_free_network_nolock(&(padapter->mlmepriv), pnetwork);
290
+
_rtw_free_network_nolock(&padapter->mlmepriv, pnetwork);
291
291
rtw_cfg80211_unlink_bss(padapter, pnetwork);
292
292
}
293
293
···
404
404
long rssi_final;
405
405
406
406
/* The rule below is 1/5 for sample value, 4/5 for history value */
407
-
if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) && is_same_network(&(padapter->mlmepriv.cur_network.network), src, 0)) {
407
+
if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) && is_same_network(&padapter->mlmepriv.cur_network.network, src, 0)) {
408
408
/* Take the recvpriv's value for the connected AP*/
409
409
ss_final = padapter->recvpriv.signal_strength;
410
410
sq_final = padapter->recvpriv.signal_qual;
···
440
440
441
441
static void update_current_network(struct adapter *adapter, struct wlan_bssid_ex *pnetwork)
442
442
{
443
-
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
443
+
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
444
444
445
-
rtw_bug_check(&(pmlmepriv->cur_network.network),
446
-
&(pmlmepriv->cur_network.network),
447
-
&(pmlmepriv->cur_network.network),
448
-
&(pmlmepriv->cur_network.network));
445
+
rtw_bug_check(&pmlmepriv->cur_network.network,
446
+
&pmlmepriv->cur_network.network,
447
+
&pmlmepriv->cur_network.network,
448
+
&pmlmepriv->cur_network.network);
449
449
450
-
if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) && (is_same_network(&(pmlmepriv->cur_network.network), pnetwork, 0))) {
451
-
update_network(&(pmlmepriv->cur_network.network), pnetwork, adapter, true);
450
+
if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) && (is_same_network(&pmlmepriv->cur_network.network, pnetwork, 0))) {
451
+
update_network(&pmlmepriv->cur_network.network, pnetwork, adapter, true);
452
452
rtw_update_protection(adapter, (pmlmepriv->cur_network.network.ies) + sizeof(struct ndis_802_11_fix_ie),
453
453
pmlmepriv->cur_network.network.ie_length);
454
454
}
···
461
461
{
462
462
struct list_head *plist, *phead;
463
463
u32 bssid_ex_sz;
464
-
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
465
-
struct __queue *queue = &(pmlmepriv->scanned_queue);
464
+
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
465
+
struct __queue *queue = &pmlmepriv->scanned_queue;
466
466
struct wlan_network *pnetwork = NULL;
467
467
struct wlan_network *oldest = NULL;
468
468
int target_find = 0;
···
475
475
476
476
rtw_bug_check(pnetwork, pnetwork, pnetwork, pnetwork);
477
477
478
-
if (is_same_network(&(pnetwork->network), target, feature)) {
478
+
if (is_same_network(&pnetwork->network, target, feature)) {
479
479
target_find = 1;
480
480
break;
481
481
}
···
499
499
if (!pnetwork)
500
500
goto exit;
501
501
502
-
memcpy(&(pnetwork->network), target, get_wlan_bssid_ex_sz(target));
502
+
memcpy(&pnetwork->network, target, get_wlan_bssid_ex_sz(target));
503
503
/* variable initialize */
504
504
pnetwork->fixed = false;
505
505
pnetwork->last_scanned = jiffies;
···
521
521
522
522
bssid_ex_sz = get_wlan_bssid_ex_sz(target);
523
523
target->length = bssid_ex_sz;
524
-
memcpy(&(pnetwork->network), target, bssid_ex_sz);
524
+
memcpy(&pnetwork->network, target, bssid_ex_sz);
525
525
526
526
pnetwork->last_scanned = jiffies;
527
527
···
529
529
if (pnetwork->network.phy_info.signal_quality == 101)
530
530
pnetwork->network.phy_info.signal_quality = 0;
531
531
532
-
list_add_tail(&(pnetwork->list), &(queue->queue));
532
+
list_add_tail(&pnetwork->list, &queue->queue);
533
533
534
534
}
535
535
} else {
···
553
553
update_ie = false;
554
554
}
555
555
556
-
update_network(&(pnetwork->network), target, adapter, update_ie);
556
+
update_network(&pnetwork->network, target, adapter, update_ie);
557
557
}
558
558
559
559
exit:
···
629
629
{
630
630
u32 len;
631
631
struct wlan_bssid_ex *pnetwork;
632
-
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
632
+
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
633
633
634
634
pnetwork = (struct wlan_bssid_ex *)pbuf;
635
635
···
641
641
642
642
/* update IBSS_network 's timestamp */
643
643
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) == true) {
644
-
if (!memcmp(&(pmlmepriv->cur_network.network.mac_address), pnetwork->mac_address, ETH_ALEN)) {
644
+
if (!memcmp(&pmlmepriv->cur_network.network.mac_address, pnetwork->mac_address, ETH_ALEN)) {
645
645
struct wlan_network *ibss_wlan = NULL;
646
646
647
647
memcpy(pmlmepriv->cur_network.network.ies, pnetwork->ies, 8);
648
-
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
648
+
spin_lock_bh(&pmlmepriv->scanned_queue.lock);
649
649
ibss_wlan = rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->mac_address);
650
650
if (ibss_wlan) {
651
651
memcpy(ibss_wlan->network.ies, pnetwork->ies, 8);
652
-
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
652
+
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
653
653
goto exit;
654
654
}
655
-
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
655
+
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
656
656
}
657
657
}
658
658
···
670
670
671
671
void rtw_surveydone_event_callback(struct adapter *adapter, u8 *pbuf)
672
672
{
673
-
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
673
+
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
674
674
675
675
spin_lock_bh(&pmlmepriv->lock);
676
676
if (pmlmepriv->wps_probe_req_ie) {
···
697
697
_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
698
698
} else {
699
699
u8 ret = _SUCCESS;
700
-
struct wlan_bssid_ex *pdev_network = &(adapter->registrypriv.dev_network);
700
+
struct wlan_bssid_ex *pdev_network = &adapter->registrypriv.dev_network;
701
701
u8 *pibss = adapter->registrypriv.dev_network.mac_address;
702
702
703
703
/* pmlmepriv->fw_state ^= _FW_UNDER_SURVEY;because don't set assoc_timer */
···
922
922
void rtw_scan_abort(struct adapter *adapter)
923
923
{
924
924
unsigned long start;
925
-
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
926
-
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
925
+
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
926
+
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
927
927
928
928
start = jiffies;
929
929
pmlmeext->scan_abort = true;
···
1029
1029
/* ptarget_wlan: found from scanned_queue */
1030
1030
static void rtw_joinbss_update_network(struct adapter *padapter, struct wlan_network *ptarget_wlan, struct wlan_network *pnetwork)
1031
1031
{
1032
-
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1033
-
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1032
+
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1033
+
struct wlan_network *cur_network = &pmlmepriv->cur_network;
1034
1034
1035
1035
/* why not use ptarget_wlan?? */
1036
1036
memcpy(&cur_network->network, &pnetwork->network, pnetwork->network.length);
···
1086
1086
static u8 __maybe_unused retry;
1087
1087
struct sta_info *ptarget_sta = NULL, *pcur_sta = NULL;
1088
1088
struct sta_priv *pstapriv = &adapter->stapriv;
1089
-
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
1089
+
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1090
1090
struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
1091
-
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1091
+
struct wlan_network *cur_network = &pmlmepriv->cur_network;
1092
1092
struct wlan_network *pcur_wlan = NULL, *ptarget_wlan = NULL;
1093
1093
unsigned int the_same_macaddr = false;
1094
-
1095
-
rtw_get_encrypt_decrypt_from_registrypriv(adapter);
1096
1094
1097
1095
the_same_macaddr = !memcmp(pnetwork->network.mac_address, cur_network->network.mac_address, ETH_ALEN);
1098
1096
···
1104
1106
pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
1105
1107
1106
1108
if (pnetwork->join_res > 0) {
1107
-
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1109
+
spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1108
1110
retry = 0;
1109
1111
if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
1110
1112
/* s1. find ptarget_wlan */
···
1141
1143
} else {
1142
1144
netdev_dbg(adapter->pnetdev,
1143
1145
"Can't find ptarget_wlan when joinbss_event callback\n");
1144
-
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1146
+
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1145
1147
goto ignore_joinbss_callback;
1146
1148
}
1147
1149
···
1149
1151
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1150
1152
ptarget_sta = rtw_joinbss_update_stainfo(adapter, pnetwork);
1151
1153
if (!ptarget_sta) {
1152
-
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1154
+
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1153
1155
goto ignore_joinbss_callback;
1154
1156
}
1155
1157
}
···
1167
1169
timer_delete_sync(&pmlmepriv->assoc_timer);
1168
1170
spin_lock_bh(&pmlmepriv->lock);
1169
1171
} else {
1170
-
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1172
+
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1171
1173
}
1172
1174
} else if (pnetwork->join_res == -4) {
1173
1175
rtw_reset_securitypriv(adapter);
···
1231
1233
void rtw_stassoc_event_callback(struct adapter *adapter, u8 *pbuf)
1232
1234
{
1233
1235
struct sta_info *psta;
1234
-
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
1236
+
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1235
1237
struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf;
1236
-
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1238
+
struct wlan_network *cur_network = &pmlmepriv->cur_network;
1237
1239
struct wlan_network *ptarget_wlan = NULL;
1238
1240
1239
1241
if (rtw_access_ctrl(adapter, pstassoc->macaddr) == false)
···
1304
1306
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
1305
1307
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) {
1306
1308
if (adapter->stapriv.asoc_sta_count == 2) {
1307
-
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1309
+
spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1308
1310
ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address);
1309
1311
pmlmepriv->cur_network_scanned = ptarget_wlan;
1310
1312
if (ptarget_wlan)
1311
1313
ptarget_wlan->fixed = true;
1312
-
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1314
+
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1313
1315
/* a sta + bc/mc_stainfo (not Ibss_stainfo) */
1314
1316
rtw_indicate_connect(adapter);
1315
1317
}
···
1327
1329
struct wlan_network *pwlan = NULL;
1328
1330
struct wlan_bssid_ex *pdev_network = NULL;
1329
1331
u8 *pibss = NULL;
1330
-
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
1332
+
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1331
1333
struct stadel_event *pstadel = (struct stadel_event *)pbuf;
1332
-
struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
1334
+
struct wlan_network *tgt_network = &pmlmepriv->cur_network;
1333
1335
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
1334
-
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1336
+
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
1335
1337
1336
1338
psta = rtw_get_stainfo(&adapter->stapriv, pstadel->macaddr);
1337
1339
if (psta)
···
1383
1385
rtw_free_assoc_resources(adapter, 1);
1384
1386
rtw_indicate_disconnect(adapter);
1385
1387
1386
-
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1388
+
spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1387
1389
/* remove the network entry in scanned_queue */
1388
1390
pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address);
1389
1391
if (pwlan) {
1390
1392
pwlan->fixed = false;
1391
1393
rtw_free_network_nolock(adapter, pwlan);
1392
1394
}
1393
-
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1395
+
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1394
1396
1395
1397
_rtw_roaming(adapter, roam_target);
1396
1398
}
···
1402
1404
1403
1405
if (adapter->stapriv.asoc_sta_count == 1) {/* a sta + bc/mc_stainfo (not Ibss_stainfo) */
1404
1406
u8 ret = _SUCCESS;
1405
-
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1407
+
spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1406
1408
/* free old ibss network */
1407
1409
pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address);
1408
1410
if (pwlan) {
1409
1411
pwlan->fixed = false;
1410
1412
rtw_free_network_nolock(adapter, pwlan);
1411
1413
}
1412
-
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1414
+
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1413
1415
/* re-create ibss */
1414
-
pdev_network = &(adapter->registrypriv.dev_network);
1416
+
pdev_network = &adapter->registrypriv.dev_network;
1415
1417
pibss = adapter->registrypriv.dev_network.mac_address;
1416
1418
1417
1419
memcpy(pdev_network, &tgt_network->network, get_wlan_bssid_ex_sz(&tgt_network->network));
···
1519
1521
{
1520
1522
struct mlme_priv *mlme = &adapter->mlmepriv;
1521
1523
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
1522
-
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1524
+
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
1523
1525
1524
1526
if (pmlmeinfo->VHT_enable) /* disable auto scan when connect to 11AC AP */
1525
1527
mlme->auto_scan_int_ms = 0;
···
1660
1662
{
1661
1663
int ret = _FAIL;
1662
1664
struct list_head *phead;
1663
-
struct __queue *queue = &(mlme->scanned_queue);
1665
+
struct __queue *queue = &mlme->scanned_queue;
1664
1666
struct wlan_network *pnetwork = NULL;
1665
1667
struct wlan_network *candidate = NULL;
1666
1668
···
1669
1671
return ret;
1670
1672
}
1671
1673
1672
-
spin_lock_bh(&(mlme->scanned_queue.lock));
1674
+
spin_lock_bh(&mlme->scanned_queue.lock);
1673
1675
phead = get_list_head(queue);
1674
1676
1675
1677
list_for_each(mlme->pscanned, phead) {
···
1693
1695
1694
1696
ret = _SUCCESS;
1695
1697
exit:
1696
-
spin_unlock_bh(&(mlme->scanned_queue.lock));
1698
+
spin_unlock_bh(&mlme->scanned_queue.lock);
1697
1699
1698
1700
return ret;
1699
1701
}
···
1754
1756
int ret;
1755
1757
struct list_head *phead;
1756
1758
struct adapter *adapter;
1757
-
struct __queue *queue = &(pmlmepriv->scanned_queue);
1759
+
struct __queue *queue = &pmlmepriv->scanned_queue;
1758
1760
struct wlan_network *pnetwork = NULL;
1759
1761
struct wlan_network *candidate = NULL;
1760
1762
1761
1763
adapter = (struct adapter *)pmlmepriv->nic_hdl;
1762
1764
1763
-
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1765
+
spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1764
1766
1765
1767
if (pmlmepriv->roam_network) {
1766
1768
candidate = pmlmepriv->roam_network;
···
1798
1800
ret = rtw_joinbss_cmd(adapter, candidate);
1799
1801
1800
1802
exit:
1801
-
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1803
+
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1802
1804
return ret;
1803
1805
}
1804
1806
···
1806
1808
{
1807
1809
struct cmd_obj *pcmd;
1808
1810
struct setauth_parm *psetauthparm;
1809
-
struct cmd_priv *pcmdpriv = &(adapter->cmdpriv);
1811
+
struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1810
1812
signed int res = _SUCCESS;
1811
1813
1812
1814
pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
···
1843
1845
u8 keylen;
1844
1846
struct cmd_obj *pcmd;
1845
1847
struct setkey_parm *psetkeyparm;
1846
-
struct cmd_priv *pcmdpriv = &(adapter->cmdpriv);
1848
+
struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1847
1849
signed int res = _SUCCESS;
1848
1850
1849
1851
psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm));
···
1866
1868
1867
1869
case _WEP40_:
1868
1870
keylen = 5;
1869
-
memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
1871
+
memcpy(&psetkeyparm->key[0], &psecuritypriv->dot11DefKey[keyid].skey[0], keylen);
1870
1872
break;
1871
1873
case _WEP104_:
1872
1874
keylen = 13;
1873
-
memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
1875
+
memcpy(&psetkeyparm->key[0], &psecuritypriv->dot11DefKey[keyid].skey[0], keylen);
1874
1876
break;
1875
1877
case _TKIP_:
1876
1878
keylen = 16;
···
2093
2095
/* pdev_network->ie_length = cpu_to_le32(sz); */
2094
2096
}
2095
2097
2096
-
void rtw_get_encrypt_decrypt_from_registrypriv(struct adapter *adapter)
2097
-
{
2098
-
}
2099
-
2100
2098
/* the function is at passive_level */
2101
2099
void rtw_joinbss_reset(struct adapter *padapter)
2102
2100
{
···
2246
2252
}
2247
2253
2248
2254
/* to disable 40M Hz support while gd_bw_40MHz_en = 0 */
2249
-
if (channel > 14) {
2250
-
if ((pregistrypriv->bw_mode & 0xf0) > 0)
2251
-
cbw40_enable = 1;
2252
-
} else {
2253
-
if ((pregistrypriv->bw_mode & 0x0f) > 0)
2254
-
cbw40_enable = 1;
2255
-
}
2255
+
if ((pregistrypriv->bw_mode & 0x0f) > 0)
2256
+
cbw40_enable = 1;
2256
2257
2257
2258
if ((cbw40_enable == 1) && (operation_bw == CHANNEL_WIDTH_40)) {
2258
2259
ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH);
···
2324
2335
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2325
2336
struct registry_priv *pregistrypriv = &padapter->registrypriv;
2326
2337
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2327
-
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2338
+
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
2328
2339
u8 cbw40_enable = 0;
2329
2340
2330
2341
if (!phtpriv->ht_option)
···
2355
2366
/* todo: */
2356
2367
}
2357
2368
2358
-
if (channel > 14) {
2359
-
if ((pregistrypriv->bw_mode & 0xf0) > 0)
2360
-
cbw40_enable = 1;
2361
-
} else {
2362
-
if ((pregistrypriv->bw_mode & 0x0f) > 0)
2363
-
cbw40_enable = 1;
2364
-
}
2369
+
if ((pregistrypriv->bw_mode & 0x0f) > 0)
2370
+
cbw40_enable = 1;
2365
2371
2366
2372
/* update cur_bwmode & cur_ch_offset */
2367
2373
if ((cbw40_enable) &&
+2
-7
drivers/staging/rtl8723bs/core/rtw_wlan_util.c
+2
-7
drivers/staging/rtl8723bs/core/rtw_wlan_util.c
···
854
854
855
855
pHT_info = (struct HT_info_element *)pIE->data;
856
856
857
-
if (pmlmeext->cur_channel > 14) {
858
-
if ((pregistrypriv->bw_mode & 0xf0) > 0)
859
-
cbw40_enable = 1;
860
-
} else {
861
-
if ((pregistrypriv->bw_mode & 0x0f) > 0)
862
-
cbw40_enable = 1;
863
-
}
857
+
if ((pregistrypriv->bw_mode & 0x0f) > 0)
858
+
cbw40_enable = 1;
864
859
865
860
if ((pHT_info->infos[0] & BIT(2)) && cbw40_enable) {
866
861
new_bwmode = CHANNEL_WIDTH_40;
+1
-1
drivers/staging/rtl8723bs/core/rtw_xmit.c
+1
-1
drivers/staging/rtl8723bs/core/rtw_xmit.c
···
381
381
while (true) {
382
382
/* IOT action */
383
383
if ((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_ATHEROS) && (pattrib->ampdu_en == true) &&
384
-
(padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
384
+
(padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
385
385
pattrib->vcs_mode = CTS_TO_SELF;
386
386
break;
387
387
}
-2
drivers/staging/rtl8723bs/hal/HalPhyRf.h
-2
drivers/staging/rtl8723bs/hal/HalPhyRf.h
···
15
15
};
16
16
17
17
typedef void (*FuncSetPwr)(struct dm_odm_t *, enum pwrtrack_method, u8, u8);
18
-
typedef void (*FuncIQK)(struct dm_odm_t *, u8, u8, u8);
19
18
typedef void (*FuncLCK)(struct dm_odm_t *);
20
19
typedef void (*FuncSwing)(struct dm_odm_t *, u8 **, u8 **, u8 **, u8 **);
21
20
···
26
27
u8 RfPathCount;
27
28
u32 ThermalRegAddr;
28
29
FuncSetPwr ODM_TxPwrTrackSetPwr;
29
-
FuncIQK DoIQK;
30
30
FuncLCK PHY_LCCalibrate;
31
31
FuncSwing GetDeltaSwingTable;
32
32
};
-10
drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.c
-10
drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.c
···
142
142
}
143
143
}
144
144
145
-
void DoIQK_8723B(
146
-
struct dm_odm_t *pDM_Odm,
147
-
u8 DeltaThermalIndex,
148
-
u8 ThermalValue,
149
-
u8 Threshold
150
-
)
151
-
{
152
-
}
153
-
154
145
/*-----------------------------------------------------------------------------
155
146
* Function: odm_TxPwrTrackSetPwr88E()
156
147
*
···
344
353
pConfig->ThermalRegAddr = RF_T_METER_8723B;
345
354
346
355
pConfig->ODM_TxPwrTrackSetPwr = ODM_TxPwrTrackSetPwr_8723B;
347
-
pConfig->DoIQK = DoIQK_8723B;
348
356
pConfig->PHY_LCCalibrate = PHY_LCCalibrate_8723B;
349
357
pConfig->GetDeltaSwingTable = GetDeltaSwingTable_8723B;
350
358
}
-7
drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.h
-7
drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.h
···
18
18
19
19
void ConfigureTxpowerTrack_8723B(struct txpwrtrack_cfg *pConfig);
20
20
21
-
void DoIQK_8723B(
22
-
struct dm_odm_t *pDM_Odm,
23
-
u8 DeltaThermalIndex,
24
-
u8 ThermalValue,
25
-
u8 Threshold
26
-
);
27
-
28
21
void ODM_TxPwrTrackSetPwr_8723B(
29
22
struct dm_odm_t *pDM_Odm,
30
23
enum pwrtrack_method Method,
-7
drivers/staging/rtl8723bs/hal/hal_com.c
-7
drivers/staging/rtl8723bs/hal/hal_com.c
···
569
569
psta->init_rate = get_highest_rate_idx(tx_ra_bitmap)&0x3f;
570
570
}
571
571
572
-
void hw_var_port_switch(struct adapter *adapter)
573
-
{
574
-
}
575
-
576
572
void SetHwReg(struct adapter *adapter, u8 variable, u8 *val)
577
573
{
578
574
struct hal_com_data *hal_data = GET_HAL_DATA(adapter);
579
575
struct dm_odm_t *odm = &(hal_data->odmpriv);
580
576
581
577
switch (variable) {
582
-
case HW_VAR_PORT_SWITCH:
583
-
hw_var_port_switch(adapter);
584
-
break;
585
578
case HW_VAR_INIT_RTS_RATE:
586
579
rtw_warn_on(1);
587
580
break;
+6
-31
drivers/staging/rtl8723bs/hal/hal_intf.c
+6
-31
drivers/staging/rtl8723bs/hal/hal_intf.c
···
38
38
rtl8723b_init_dm_priv(padapter);
39
39
}
40
40
41
-
void rtw_hal_dm_deinit(struct adapter *padapter)
42
-
{
43
-
}
44
-
45
41
static void rtw_hal_init_opmode(struct adapter *padapter)
46
42
{
47
43
enum ndis_802_11_network_infrastructure networkType = Ndis802_11InfrastructureMax;
···
72
76
73
77
if (padapter->registrypriv.notch_filter == 1)
74
78
rtw_hal_notch_filter(padapter, 1);
75
-
76
-
rtw_hal_reset_security_engine(padapter);
77
79
78
80
rtw_sec_restore_wep_key(dvobj->padapters);
79
81
···
127
133
128
134
void rtw_hal_set_odm_var(struct adapter *padapter, enum hal_odm_variable eVariable, void *pValue1, bool bSet)
129
135
{
130
-
if (padapter->HalFunc.SetHalODMVarHandler)
131
-
padapter->HalFunc.SetHalODMVarHandler(padapter, eVariable, pValue1, bSet);
136
+
SetHalODMVar(padapter, eVariable, pValue1, bSet);
132
137
}
133
138
134
139
void rtw_hal_enable_interrupt(struct adapter *padapter)
···
283
290
284
291
s32 rtw_hal_xmit_thread_handler(struct adapter *padapter)
285
292
{
286
-
if (padapter->HalFunc.xmit_thread_handler)
287
-
return padapter->HalFunc.xmit_thread_handler(padapter);
288
-
return _FAIL;
293
+
return rtl8723bs_xmit_buf_handler(padapter);
289
294
}
290
295
291
296
void rtw_hal_notch_filter(struct adapter *adapter, bool enable)
292
297
{
293
-
if (adapter->HalFunc.hal_notch_filter)
294
-
adapter->HalFunc.hal_notch_filter(adapter, enable);
295
-
}
296
-
297
-
void rtw_hal_reset_security_engine(struct adapter *adapter)
298
-
{
299
-
if (adapter->HalFunc.hal_reset_security_engine)
300
-
adapter->HalFunc.hal_reset_security_engine(adapter);
298
+
hal_notch_filter_8723b(adapter, enable);
301
299
}
302
300
303
301
bool rtw_hal_c2h_valid(struct adapter *adapter, u8 *buf)
···
298
314
299
315
s32 rtw_hal_c2h_handler(struct adapter *adapter, u8 *c2h_evt)
300
316
{
301
-
s32 ret = _FAIL;
302
-
303
-
if (adapter->HalFunc.c2h_handler)
304
-
ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt);
305
-
return ret;
317
+
return c2h_handler_8723b(adapter, c2h_evt);
306
318
}
307
319
308
320
c2h_id_filter rtw_hal_c2h_id_filter_ccx(struct adapter *adapter)
309
321
{
310
-
return adapter->HalFunc.c2h_id_filter_ccx;
322
+
return c2h_id_filter_ccx_8723b;
311
323
}
312
324
313
325
s32 rtw_hal_macid_sleep(struct adapter *padapter, u32 macid)
···
336
356
337
357
s32 rtw_hal_fill_h2c_cmd(struct adapter *padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
338
358
{
339
-
s32 ret = _FAIL;
340
-
341
-
if (padapter->HalFunc.fill_h2c_cmd)
342
-
ret = padapter->HalFunc.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer);
343
-
344
-
return ret;
359
+
return FillH2CCmd8723B(padapter, ElementID, CmdLen, pCmdBuffer);
345
360
}
-10
drivers/staging/rtl8723bs/hal/odm.c
-10
drivers/staging/rtl8723bs/hal/odm.c
···
315
315
pDM_Odm->bOneEntryOnly = false;
316
316
}
317
317
318
-
static void odm_CmnInfoInit_Debug(struct dm_odm_t *pDM_Odm)
319
-
{
320
-
}
321
-
322
-
static void odm_BasicDbgMessage(struct dm_odm_t *pDM_Odm)
323
-
{
324
-
}
325
-
326
318
/* 3 ============================================================ */
327
319
/* 3 RATR MASK */
328
320
/* 3 ============================================================ */
···
727
735
{
728
736
729
737
odm_CommonInfoSelfInit(pDM_Odm);
730
-
odm_CmnInfoInit_Debug(pDM_Odm);
731
738
odm_DIGInit(pDM_Odm);
732
739
odm_NHMCounterStatisticsInit(pDM_Odm);
733
740
odm_AdaptivityInit(pDM_Odm);
···
752
761
void ODM_DMWatchdog(struct dm_odm_t *pDM_Odm)
753
762
{
754
763
odm_CommonInfoSelfUpdate(pDM_Odm);
755
-
odm_BasicDbgMessage(pDM_Odm);
756
764
odm_FalseAlarmCounterStatistics(pDM_Odm);
757
765
odm_NHMCounterStatistics(pDM_Odm);
758
766
-1
drivers/staging/rtl8723bs/hal/odm_DIG.c
-1
drivers/staging/rtl8723bs/hal/odm_DIG.c
+4
-23
drivers/staging/rtl8723bs/hal/rtl8723b_cmd.c
+4
-23
drivers/staging/rtl8723bs/hal/rtl8723b_cmd.c
···
57
57
if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->h2c_fwcmd_mutex)))
58
58
return ret;
59
59
60
-
if (!pCmdBuffer) {
60
+
if (!pCmdBuffer)
61
61
goto exit;
62
-
}
63
62
64
-
if (CmdLen > RTL8723B_MAX_CMD_LEN) {
63
+
if (CmdLen > RTL8723B_MAX_CMD_LEN)
65
64
goto exit;
66
-
}
67
65
68
66
if (padapter->bSurpriseRemoved)
69
67
goto exit;
···
285
287
*pLength = pktlen;
286
288
}
287
289
288
-
/*
289
-
* To check if reserved page content is destroyed by beacon because beacon
290
-
* is too large.
291
-
*/
292
-
/* 2010.06.23. Added by tynli. */
293
-
void CheckFwRsvdPageContent(struct adapter *Adapter)
294
-
{
295
-
}
296
-
297
290
static void rtl8723b_set_FwRsvdPage_cmd(struct adapter *padapter, struct rsvdpage_loc *rsvdpageloc)
298
291
{
299
292
u8 u1H2CRsvdPageParm[H2C_RSVDPAGE_LOC_LEN] = {0};
···
296
307
SET_8723B_H2CCMD_RSVDPAGE_LOC_BT_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocBTQosNull);
297
308
298
309
FillH2CCmd8723B(padapter, H2C_8723B_RSVD_PAGE, H2C_RSVDPAGE_LOC_LEN, u1H2CRsvdPageParm);
299
-
}
300
-
301
-
static void rtl8723b_set_FwAoacRsvdPage_cmd(struct adapter *padapter, struct rsvdpage_loc *rsvdpageloc)
302
-
{
303
310
}
304
311
305
312
void rtl8723b_set_FwMediaStatusRpt_cmd(struct adapter *padapter, u8 mstatus, u8 macid)
···
599
614
dump_mgntframe_and_wait(padapter, pcmdframe, 100);
600
615
}
601
616
602
-
if (check_fwstate(pmlmepriv, _FW_LINKED)) {
617
+
if (check_fwstate(pmlmepriv, _FW_LINKED))
603
618
rtl8723b_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);
604
-
rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
605
-
} else {
606
-
rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
607
-
}
619
+
608
620
return;
609
621
610
622
error:
···
867
885
dump_mgntframe_and_wait(padapter, pcmdframe, 100);
868
886
869
887
rtl8723b_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);
870
-
rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
871
888
872
889
return;
873
890
-7
drivers/staging/rtl8723bs/hal/rtl8723b_dm.c
-7
drivers/staging/rtl8723bs/hal/rtl8723b_dm.c
···
12
12
13
13
/* Global var */
14
14
15
-
static void dm_CheckStatistics(struct adapter *Adapter)
16
-
{
17
-
}
18
15
/* */
19
16
/* functions */
20
17
/* */
···
141
144
(hw_init_completed == true) &&
142
145
((!fw_current_in_ps_mode) && bFwPSAwake)
143
146
) {
144
-
/* */
145
-
/* Calculate Tx/Rx statistics. */
146
-
/* */
147
-
dm_CheckStatistics(Adapter);
148
147
rtw_hal_check_rxfifo_full(Adapter);
149
148
}
150
149
+2
-96
drivers/staging/rtl8723bs/hal/rtl8723b_hal_init.c
+2
-96
drivers/staging/rtl8723bs/hal/rtl8723b_hal_init.c
···
1077
1077
return ret;
1078
1078
}
1079
1079
1080
-
static u8 Hal_EfuseWordEnableDataWrite(
1081
-
struct adapter *padapter,
1082
-
u16 efuse_addr,
1083
-
u8 word_en,
1084
-
u8 *data,
1085
-
bool bPseudoTest
1086
-
)
1087
-
{
1088
-
u16 tmpaddr = 0;
1089
-
u16 start_addr = efuse_addr;
1090
-
u8 badworden = 0x0F;
1091
-
u8 tmpdata[PGPKT_DATA_SIZE];
1092
-
1093
-
memset(tmpdata, 0xFF, PGPKT_DATA_SIZE);
1094
-
1095
-
if (!(word_en & BIT(0))) {
1096
-
tmpaddr = start_addr;
1097
-
efuse_OneByteWrite(padapter, start_addr++, data[0], bPseudoTest);
1098
-
efuse_OneByteWrite(padapter, start_addr++, data[1], bPseudoTest);
1099
-
1100
-
efuse_OneByteRead(padapter, tmpaddr, &tmpdata[0], bPseudoTest);
1101
-
efuse_OneByteRead(padapter, tmpaddr+1, &tmpdata[1], bPseudoTest);
1102
-
if ((data[0] != tmpdata[0]) || (data[1] != tmpdata[1])) {
1103
-
badworden &= (~BIT(0));
1104
-
}
1105
-
}
1106
-
if (!(word_en & BIT(1))) {
1107
-
tmpaddr = start_addr;
1108
-
efuse_OneByteWrite(padapter, start_addr++, data[2], bPseudoTest);
1109
-
efuse_OneByteWrite(padapter, start_addr++, data[3], bPseudoTest);
1110
-
1111
-
efuse_OneByteRead(padapter, tmpaddr, &tmpdata[2], bPseudoTest);
1112
-
efuse_OneByteRead(padapter, tmpaddr+1, &tmpdata[3], bPseudoTest);
1113
-
if ((data[2] != tmpdata[2]) || (data[3] != tmpdata[3])) {
1114
-
badworden &= (~BIT(1));
1115
-
}
1116
-
}
1117
-
1118
-
if (!(word_en & BIT(2))) {
1119
-
tmpaddr = start_addr;
1120
-
efuse_OneByteWrite(padapter, start_addr++, data[4], bPseudoTest);
1121
-
efuse_OneByteWrite(padapter, start_addr++, data[5], bPseudoTest);
1122
-
1123
-
efuse_OneByteRead(padapter, tmpaddr, &tmpdata[4], bPseudoTest);
1124
-
efuse_OneByteRead(padapter, tmpaddr+1, &tmpdata[5], bPseudoTest);
1125
-
if ((data[4] != tmpdata[4]) || (data[5] != tmpdata[5])) {
1126
-
badworden &= (~BIT(2));
1127
-
}
1128
-
}
1129
-
1130
-
if (!(word_en & BIT(3))) {
1131
-
tmpaddr = start_addr;
1132
-
efuse_OneByteWrite(padapter, start_addr++, data[6], bPseudoTest);
1133
-
efuse_OneByteWrite(padapter, start_addr++, data[7], bPseudoTest);
1134
-
1135
-
efuse_OneByteRead(padapter, tmpaddr, &tmpdata[6], bPseudoTest);
1136
-
efuse_OneByteRead(padapter, tmpaddr+1, &tmpdata[7], bPseudoTest);
1137
-
if ((data[6] != tmpdata[6]) || (data[7] != tmpdata[7])) {
1138
-
badworden &= (~BIT(3));
1139
-
}
1140
-
}
1141
-
1142
-
return badworden;
1143
-
}
1144
-
1145
1080
static struct hal_version ReadChipVersion8723B(struct adapter *padapter)
1146
1081
{
1147
1082
u32 value32;
···
1196
1261
rtw_write8(padapter, REG_TBTT_PROHIBIT+1, 0x64);
1197
1262
pHalData->RegReg542 &= ~BIT(0);
1198
1263
rtw_write8(padapter, REG_TBTT_PROHIBIT+2, pHalData->RegReg542);
1199
-
1200
-
CheckFwRsvdPageContent(padapter); /* 2010.06.23. Added by tynli. */
1201
1264
}
1202
1265
1203
1266
static void _BeaconFunctionEnable(struct adapter *padapter, u8 Enable, u8 Linked)
···
1265
1332
rtw_write8(padapter, bcn_ctrl_reg, val8);
1266
1333
}
1267
1334
1268
-
static void rtl8723b_SetHalODMVar(
1269
-
struct adapter *Adapter,
1270
-
enum hal_odm_variable eVariable,
1271
-
void *pValue1,
1272
-
bool bSet
1273
-
)
1274
-
{
1275
-
SetHalODMVar(Adapter, eVariable, pValue1, bSet);
1276
-
}
1277
-
1278
-
static void hal_notch_filter_8723b(struct adapter *adapter, bool enable)
1335
+
void hal_notch_filter_8723b(struct adapter *adapter, bool enable)
1279
1336
{
1280
1337
if (enable)
1281
1338
rtw_write8(adapter, rOFDM0_RxDSP+1, rtw_read8(adapter, rOFDM0_RxDSP+1) | BIT1);
···
1308
1385
1309
1386
/* set correct initial date rate for each mac_id */
1310
1387
pdmpriv->INIDATA_RATE[mac_id] = psta->init_rate;
1311
-
}
1312
-
1313
-
1314
-
void rtl8723b_set_hal_ops(struct hal_ops *pHalFunc)
1315
-
{
1316
-
/* Efuse related function */
1317
-
pHalFunc->Efuse_WordEnableDataWrite = &Hal_EfuseWordEnableDataWrite;
1318
-
1319
-
pHalFunc->SetHalODMVarHandler = &rtl8723b_SetHalODMVar;
1320
-
1321
-
pHalFunc->xmit_thread_handler = &hal_xmit_handler;
1322
-
pHalFunc->hal_notch_filter = &hal_notch_filter_8723b;
1323
-
1324
-
pHalFunc->c2h_handler = c2h_handler_8723b;
1325
-
pHalFunc->c2h_id_filter_ccx = c2h_id_filter_ccx_8723b;
1326
-
1327
-
pHalFunc->fill_h2c_cmd = &FillH2CCmd8723B;
1328
1388
}
1329
1389
1330
1390
void rtl8723b_InitAntenna_Selection(struct adapter *padapter)
···
3091
3185
break;
3092
3186
case HW_VAR_CHK_HI_QUEUE_EMPTY:
3093
3187
val16 = rtw_read16(padapter, REG_TXPKT_EMPTY);
3094
-
*val = (val16 & BIT(10)) ? true:false;
3188
+
*val = (val16 & BIT(10)) ? true : false;
3095
3189
break;
3096
3190
default:
3097
3191
GetHwReg(padapter, variable, val);
-13
drivers/staging/rtl8723bs/hal/sdio_halinit.c
-13
drivers/staging/rtl8723bs/hal/sdio_halinit.c
···
1094
1094
_ReadEfuseInfo8723BS(padapter);
1095
1095
}
1096
1096
1097
-
static void _InitOtherVariable(struct adapter *Adapter)
1098
-
{
1099
-
}
1100
-
1101
1097
/* */
1102
1098
/* Description: */
1103
1099
/* Read HW adapter information by E-Fuse or EEPROM according CR9346 reported. */
···
1118
1122
_EfuseCellSel(padapter);
1119
1123
_ReadRFType(padapter);
1120
1124
_ReadPROMContent(padapter);
1121
-
_InitOtherVariable(padapter);
1122
1125
1123
1126
if (!padapter->hw_init_completed) {
1124
1127
rtw_write8(padapter, 0x67, 0x00); /* for BT, Switch Ant control to BT */
···
1245
1250
u8 SetHalDefVar8723BSDIO(struct adapter *Adapter, enum hal_def_variable eVariable, void *pValue)
1246
1251
{
1247
1252
return SetHalDefVar8723B(Adapter, eVariable, pValue);
1248
-
}
1249
-
1250
-
void rtl8723bs_set_hal_ops(struct adapter *padapter)
1251
-
{
1252
-
struct hal_ops *pHalFunc = &padapter->HalFunc;
1253
-
1254
-
rtl8723b_set_hal_ops(pHalFunc);
1255
-
1256
1253
}
+1
-1
drivers/staging/rtl8723bs/include/basic_types.h
+1
-1
drivers/staging/rtl8723bs/include/basic_types.h
···
163
163
( \
164
164
LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) | \
165
165
((((u16)__val) & BIT_LEN_MASK_16(__bitlen)) << (__bitoffset)) \
166
-
);
166
+
)
167
167
168
168
#define SET_BITS_TO_LE_1BYTE(__pstart, __bitoffset, __bitlen, __val) \
169
169
*((u8 *)(__pstart)) = EF1BYTE \
-1
drivers/staging/rtl8723bs/include/drv_types.h
-1
drivers/staging/rtl8723bs/include/drv_types.h
-2
drivers/staging/rtl8723bs/include/hal_com.h
-2
drivers/staging/rtl8723bs/include/hal_com.h
···
134
134
u8 rtw_get_mgntframe_raid(struct adapter *adapter, unsigned char network_type);
135
135
void rtw_hal_update_sta_rate_mask(struct adapter *padapter, struct sta_info *psta);
136
136
137
-
void hw_var_port_switch(struct adapter *adapter);
138
-
139
137
void SetHwReg(struct adapter *padapter, u8 variable, u8 *val);
140
138
void GetHwReg(struct adapter *padapter, u8 variable, u8 *val);
141
139
void rtw_hal_check_rxfifo_full(struct adapter *adapter);
+1
-16
drivers/staging/rtl8723bs/include/hal_intf.h
+1
-16
drivers/staging/rtl8723bs/include/hal_intf.h
···
160
160
161
161
typedef s32 (*c2h_id_filter)(u8 *c2h_evt);
162
162
163
-
struct hal_ops {
164
-
void (*SetHalODMVarHandler)(struct adapter *padapter, enum hal_odm_variable eVariable, void *pValue1, bool bSet);
165
-
166
-
u8 (*Efuse_WordEnableDataWrite)(struct adapter *padapter, u16 efuse_addr, u8 word_en, u8 *data, bool bPseudoTest);
167
-
168
-
s32 (*xmit_thread_handler)(struct adapter *padapter);
169
-
void (*hal_notch_filter)(struct adapter *adapter, bool enable);
170
-
void (*hal_reset_security_engine)(struct adapter *adapter);
171
-
s32 (*c2h_handler)(struct adapter *padapter, u8 *c2h_evt);
172
-
c2h_id_filter c2h_id_filter_ccx;
173
-
174
-
s32 (*fill_h2c_cmd)(struct adapter *, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer);
175
-
};
176
-
177
163
#define RF_CHANGE_BY_INIT 0
178
164
#define RF_CHANGE_BY_IPS BIT28
179
165
#define RF_CHANGE_BY_PS BIT29
···
186
200
void rtw_hal_free_data(struct adapter *padapter);
187
201
188
202
void rtw_hal_dm_init(struct adapter *padapter);
189
-
void rtw_hal_dm_deinit(struct adapter *padapter);
190
203
191
204
uint rtw_hal_init(struct adapter *padapter);
192
205
uint rtw_hal_deinit(struct adapter *padapter);
···
248
263
s32 rtw_hal_xmit_thread_handler(struct adapter *padapter);
249
264
250
265
void rtw_hal_notch_filter(struct adapter *adapter, bool enable);
251
-
void rtw_hal_reset_security_engine(struct adapter *adapter);
252
266
253
267
bool rtw_hal_c2h_valid(struct adapter *adapter, u8 *buf);
254
268
s32 rtw_hal_c2h_handler(struct adapter *adapter, u8 *c2h_evt);
···
271
287
void Hal_GetEfuseDefinition(struct adapter *padapter, u8 efuseType, u8 type,
272
288
void *pOut, bool bPseudoTest);
273
289
u16 Hal_EfuseGetCurrentSize(struct adapter *padapter, u8 efuseType, bool bPseudoTest);
290
+
void hal_notch_filter_8723b(struct adapter *adapter, bool enable);
274
291
#endif /* __HAL_INTF_H__ */
+1
drivers/staging/rtl8723bs/include/ioctl_cfg80211.h
+1
drivers/staging/rtl8723bs/include/ioctl_cfg80211.h
···
94
94
95
95
void rtw_cfg80211_unlink_bss(struct adapter *padapter, struct wlan_network *pnetwork);
96
96
void rtw_cfg80211_surveydone_event_callback(struct adapter *padapter);
97
+
int rtw_ieee80211_channel_to_frequency(int chan);
97
98
struct cfg80211_bss *rtw_cfg80211_inform_bss(struct adapter *padapter, struct wlan_network *pnetwork);
98
99
int rtw_cfg80211_check_bss(struct adapter *padapter);
99
100
void rtw_cfg80211_ibss_indicate_connect(struct adapter *padapter);
-3
drivers/staging/rtl8723bs/include/rtl8723b_cmd.h
-3
drivers/staging/rtl8723bs/include/rtl8723b_cmd.h
···
175
175
void rtl8723b_download_rsvd_page(struct adapter *padapter, u8 mstatus);
176
176
void rtl8723b_download_BTCoex_AP_mode_rsvd_page(struct adapter *padapter);
177
177
178
-
void CheckFwRsvdPageContent(struct adapter *padapter);
179
-
180
178
void rtl8723b_set_FwPwrModeInIPS_cmd(struct adapter *padapter, u8 cmd_param);
181
179
182
180
s32 FillH2CCmd8723B(struct adapter *padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer);
183
181
184
-
#define FillH2CCmd FillH2CCmd8723B
185
182
#endif
-1
drivers/staging/rtl8723bs/include/rtl8723b_hal.h
-1
drivers/staging/rtl8723bs/include/rtl8723b_hal.h
···
223
223
224
224
void C2HPacketHandler_8723B(struct adapter *padapter, u8 *pbuffer, u16 length);
225
225
226
-
void rtl8723b_set_hal_ops(struct hal_ops *pHalFunc);
227
226
void SetHwReg8723B(struct adapter *padapter, u8 variable, u8 *val);
228
227
void GetHwReg8723B(struct adapter *padapter, u8 variable, u8 *val);
229
228
u8 SetHalDefVar8723B(struct adapter *padapter, enum hal_def_variable variable,
-1
drivers/staging/rtl8723bs/include/rtl8723b_xmit.h
-1
drivers/staging/rtl8723bs/include/rtl8723b_xmit.h
···
414
414
s32 rtl8723bs_hal_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe);
415
415
s32 rtl8723bs_xmit_buf_handler(struct adapter *padapter);
416
416
int rtl8723bs_xmit_thread(void *context);
417
-
#define hal_xmit_handler rtl8723bs_xmit_buf_handler
418
417
419
418
u8 BWMapping_8723B(struct adapter *Adapter, struct pkt_attrib *pattrib);
420
419
u8 SCMapping_8723B(struct adapter *Adapter, struct pkt_attrib *pattrib);
-1
drivers/staging/rtl8723bs/include/rtw_efuse.h
-1
drivers/staging/rtl8723bs/include/rtw_efuse.h
···
96
96
u8 efuse_OneByteWrite(struct adapter *padapter, u16 addr, u8 data, bool bPseudoTest);
97
97
98
98
void Efuse_PowerSwitch(struct adapter *padapter, u8 bWrite, u8 PwrState);
99
-
u8 Efuse_WordEnableDataWrite(struct adapter *padapter, u16 efuse_addr, u8 word_en, u8 *data, bool bPseudoTest);
100
99
101
100
u8 EFUSE_Read1Byte(struct adapter *padapter, u16 Address);
102
101
void EFUSE_ShadowMapUpdate(struct adapter *padapter, u8 efuseType, bool bPseudoTest);
-2
drivers/staging/rtl8723bs/include/rtw_mlme.h
-2
drivers/staging/rtl8723bs/include/rtw_mlme.h
···
341
341
342
342
extern void rtw_update_registrypriv_dev_network(struct adapter *adapter);
343
343
344
-
extern void rtw_get_encrypt_decrypt_from_registrypriv(struct adapter *adapter);
345
-
346
344
extern void _rtw_join_timeout_handler(struct timer_list *t);
347
345
extern void rtw_scan_timeout_handler(struct timer_list *t);
348
346
-2
drivers/staging/rtl8723bs/include/sdio_hal.h
-2
drivers/staging/rtl8723bs/include/sdio_hal.h
+12
-12
drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c
+12
-12
drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c
···
192
192
},
193
193
};
194
194
195
-
static int rtw_ieee80211_channel_to_frequency(int chan, int band)
195
+
int rtw_ieee80211_channel_to_frequency(int chan)
196
196
{
197
-
if (band == NL80211_BAND_2GHZ) {
198
-
if (chan == 14)
199
-
return 2484;
200
-
else if (chan < 14)
201
-
return 2407 + chan * 5;
202
-
}
197
+
/* NL80211_BAND_2GHZ */
198
+
if (chan == 14)
199
+
return 2484;
200
+
201
+
if (chan < 14)
202
+
return 2407 + chan * 5;
203
203
204
204
return 0; /* not supported */
205
205
}
···
266
266
/* spin_unlock_bh(&pwdev_priv->scan_req_lock); */
267
267
268
268
channel = pnetwork->network.configuration.ds_config;
269
-
freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
269
+
freq = rtw_ieee80211_channel_to_frequency(channel);
270
270
271
271
notify_channel = ieee80211_get_channel(wiphy, freq);
272
272
···
340
340
if (!(pnetwork) || !(padapter->rtw_wdev))
341
341
return false;
342
342
343
-
freq = rtw_ieee80211_channel_to_frequency(pnetwork->configuration.ds_config, NL80211_BAND_2GHZ);
343
+
freq = rtw_ieee80211_channel_to_frequency(pnetwork->configuration.ds_config);
344
344
345
345
notify_channel = ieee80211_get_channel(padapter->rtw_wdev->wiphy, freq);
346
346
bss = cfg80211_get_bss(padapter->rtw_wdev->wiphy, notify_channel,
···
440
440
u16 channel = cur_network->network.configuration.ds_config;
441
441
struct cfg80211_roam_info roam_info = {};
442
442
443
-
freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
443
+
freq = rtw_ieee80211_channel_to_frequency(channel);
444
444
445
445
notify_channel = ieee80211_get_channel(wiphy, freq);
446
446
···
1976
1976
if (!channel)
1977
1977
return -ENODATA;
1978
1978
1979
-
freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
1979
+
freq = rtw_ieee80211_channel_to_frequency(channel);
1980
1980
1981
1981
chan = ieee80211_get_channel(adapter->rtw_wdev->wiphy, freq);
1982
1982
···
2456
2456
2457
2457
rtw_action_frame_parse(frame, frame_len, &category, &action);
2458
2458
2459
-
freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
2459
+
freq = rtw_ieee80211_channel_to_frequency(channel);
2460
2460
2461
2461
rtw_cfg80211_rx_mgmt(adapter, freq, 0, frame, frame_len, GFP_ATOMIC);
2462
2462
}
+4
-15
drivers/staging/rtl8723bs/os_dep/os_intfs.c
+4
-15
drivers/staging/rtl8723bs/os_dep/os_intfs.c
···
99
99
static int rtw_antdiv_cfg = 1; /* 0:OFF , 1:ON, 2:decide by Efuse config */
100
100
static int rtw_antdiv_type; /* 0:decide by efuse 1: for 88EE, 1Tx and 1RxCG are diversity.(2 Ant with SPDT), 2: for 88EE, 1Tx and 2Rx are diversity.(2 Ant, Tx and RxCG are both on aux port, RxCS is on main port), 3: for 88EE, 1Tx and 1RxCG are fixed.(1Ant, Tx and RxCG are both on aux port) */
101
101
102
-
103
-
104
102
static int rtw_hw_wps_pbc;
105
103
106
104
int rtw_mc2u_disable;
···
521
523
pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */
522
524
523
525
/* security_priv */
524
-
/* rtw_get_encrypt_decrypt_from_registrypriv(padapter); */
525
526
psecuritypriv->binstallGrpkey = _FAIL;
526
527
psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt;
527
528
psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt;
···
624
627
padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE;
625
628
626
629
rtw_set_signal_stat_timer(&padapter->recvpriv);
627
-
628
630
}
629
631
630
632
···
705
709
rtw_clear_scan_deny(padapter);
706
710
707
711
timer_delete_sync(&padapter->recvpriv.signal_stat_timer);
708
-
709
-
/* cancel dm timer */
710
-
rtw_hal_dm_deinit(padapter);
711
712
}
712
713
713
714
u8 rtw_free_drv_sw(struct adapter *padapter)
···
915
922
mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
916
923
}
917
924
} else {
918
-
status = (_SUCCESS == ips_netdrv_open(padapter)) ? (0) : (-1);
925
+
status = (ips_netdrv_open(padapter) == _SUCCESS) ? (0) : (-1);
919
926
}
920
927
921
928
return status;
···
1105
1112
1106
1113
if ((!padapter->bup) || (padapter->bDriverStopped) || (padapter->bSurpriseRemoved)) {
1107
1114
pdbgpriv->dbg_suspend_error_cnt++;
1108
-
goto exit;
1115
+
return;
1109
1116
}
1110
1117
rtw_ps_deny(padapter, PS_DENY_SUSPEND);
1111
1118
···
1127
1134
1128
1135
netdev_dbg(padapter->pnetdev, "rtw suspend success in %d ms\n",
1129
1136
jiffies_to_msecs(jiffies - start_time));
1130
-
1131
-
exit:
1132
-
1133
-
return;
1134
1137
}
1135
1138
1136
1139
static int rtw_resume_process_normal(struct adapter *padapter)
···
1200
1211
1201
1212
hal_btcoex_SuspendNotify(padapter, 0);
1202
1213
1203
-
if (pwrpriv) {
1214
+
if (pwrpriv)
1204
1215
pwrpriv->bInSuspend = false;
1205
-
}
1216
+
1206
1217
netdev_dbg(padapter->pnetdev, "%s:%d in %d ms\n", __func__, ret,
1207
1218
jiffies_to_msecs(jiffies - start_time));
1208
1219
+1
-3
drivers/staging/rtl8723bs/os_dep/sdio_intf.c
+1
-3
drivers/staging/rtl8723bs/os_dep/sdio_intf.c
···
216
216
{
217
217
/* alloc memory for HAL DATA */
218
218
rtw_hal_data_init(padapter);
219
-
220
-
rtl8723bs_set_hal_ops(padapter);
221
219
}
222
220
223
221
static void sd_intf_start(struct adapter *padapter)
···
287
289
288
290
rtw_hal_chip_configure(padapter);
289
291
290
-
hal_btcoex_Initialize((void *) padapter);
292
+
hal_btcoex_Initialize((void *)padapter);
291
293
292
294
/* 3 6. read efuse/eeprom data */
293
295
rtw_hal_read_chip_info(padapter);
-1
drivers/staging/rtl8723bs/os_dep/sdio_ops_linux.c
-1
drivers/staging/rtl8723bs/os_dep/sdio_ops_linux.c
+1
-15
drivers/staging/rtl8723bs/os_dep/wifi_regd.c
+1
-15
drivers/staging/rtl8723bs/os_dep/wifi_regd.c
···
41
41
}
42
42
};
43
43
44
-
static int rtw_ieee80211_channel_to_frequency(int chan, int band)
45
-
{
46
-
/* NL80211_BAND_2GHZ */
47
-
if (chan == 14)
48
-
return 2484;
49
-
else if (chan < 14)
50
-
return 2407 + chan * 5;
51
-
else
52
-
return 0; /* not supported */
53
-
}
54
-
55
44
static void _rtw_reg_apply_flags(struct wiphy *wiphy)
56
45
{
57
46
struct adapter *padapter = wiphy_to_adapter(wiphy);
···
71
82
/* channels apply by channel plans. */
72
83
for (i = 0; i < max_chan_nums; i++) {
73
84
channel = channel_set[i].ChannelNum;
74
-
freq =
75
-
rtw_ieee80211_channel_to_frequency(channel,
76
-
NL80211_BAND_2GHZ);
77
-
85
+
freq = rtw_ieee80211_channel_to_frequency(channel);
78
86
ch = ieee80211_get_channel(wiphy, freq);
79
87
if (ch) {
80
88
if (channel_set[i].ScanType == SCAN_PASSIVE)
+20
-16
drivers/staging/sm750fb/sm750.c
+20
-16
drivers/staging/sm750fb/sm750.c
···
126
126
127
127
if (fbcursor->set & FB_CUR_SETPOS)
128
128
sm750_hw_cursor_set_pos(cursor,
129
-
fbcursor->image.dx - info->var.xoffset,
130
-
fbcursor->image.dy - info->var.yoffset);
129
+
fbcursor->image.dx - info->var.xoffset,
130
+
fbcursor->image.dy - info->var.yoffset);
131
131
132
132
if (fbcursor->set & FB_CUR_SETCMAP) {
133
133
/* get the 16bit color of kernel means */
···
160
160
{
161
161
struct lynxfb_par *par;
162
162
struct sm750_dev *sm750_dev;
163
-
unsigned int base, pitch, Bpp, rop;
163
+
unsigned int base, pitch, bpp, rop;
164
164
u32 color;
165
165
166
166
if (info->state != FBINFO_STATE_RUNNING)
···
175
175
*/
176
176
base = par->crtc.o_screen;
177
177
pitch = info->fix.line_length;
178
-
Bpp = info->var.bits_per_pixel >> 3;
178
+
bpp = info->var.bits_per_pixel >> 3;
179
179
180
-
color = (Bpp == 1) ? region->color :
180
+
color = (bpp == 1) ? region->color :
181
181
((u32 *)info->pseudo_palette)[region->color];
182
182
rop = (region->rop != ROP_COPY) ? HW_ROP2_XOR : HW_ROP2_COPY;
183
183
···
190
190
spin_lock(&sm750_dev->slock);
191
191
192
192
sm750_dev->accel.de_fillrect(&sm750_dev->accel,
193
-
base, pitch, Bpp,
193
+
base, pitch, bpp,
194
194
region->dx, region->dy,
195
195
region->width, region->height,
196
196
color, rop);
···
202
202
{
203
203
struct lynxfb_par *par;
204
204
struct sm750_dev *sm750_dev;
205
-
unsigned int base, pitch, Bpp;
205
+
unsigned int base, pitch, bpp;
206
206
207
207
par = info->par;
208
208
sm750_dev = par->dev;
···
213
213
*/
214
214
base = par->crtc.o_screen;
215
215
pitch = info->fix.line_length;
216
-
Bpp = info->var.bits_per_pixel >> 3;
216
+
bpp = info->var.bits_per_pixel >> 3;
217
217
218
218
/*
219
219
* If not use spin_lock, system will die if user load driver
···
225
225
226
226
sm750_dev->accel.de_copyarea(&sm750_dev->accel,
227
227
base, pitch, region->sx, region->sy,
228
-
base, pitch, Bpp, region->dx, region->dy,
228
+
base, pitch, bpp, region->dx, region->dy,
229
229
region->width, region->height,
230
230
HW_ROP2_COPY);
231
231
spin_unlock(&sm750_dev->slock);
···
234
234
static void lynxfb_ops_imageblit(struct fb_info *info,
235
235
const struct fb_image *image)
236
236
{
237
-
unsigned int base, pitch, Bpp;
237
+
unsigned int base, pitch, bpp;
238
238
unsigned int fgcol, bgcol;
239
239
struct lynxfb_par *par;
240
240
struct sm750_dev *sm750_dev;
···
247
247
*/
248
248
base = par->crtc.o_screen;
249
249
pitch = info->fix.line_length;
250
-
Bpp = info->var.bits_per_pixel >> 3;
250
+
bpp = info->var.bits_per_pixel >> 3;
251
251
252
252
/* TODO: Implement hardware acceleration for image->depth > 1 */
253
253
if (image->depth != 1) {
···
274
274
275
275
sm750_dev->accel.de_imageblit(&sm750_dev->accel,
276
276
image->data, image->width >> 3, 0,
277
-
base, pitch, Bpp,
277
+
base, pitch, bpp,
278
278
image->dx, image->dy,
279
279
image->width, image->height,
280
280
fgcol, bgcol, HW_ROP2_COPY);
···
571
571
572
572
static int lynxfb_ops_blank(int blank, struct fb_info *info)
573
573
{
574
+
struct sm750_dev *sm750_dev;
574
575
struct lynxfb_par *par;
575
576
struct lynxfb_output *output;
576
577
577
578
pr_debug("blank = %d.\n", blank);
578
579
par = info->par;
579
580
output = &par->output;
580
-
return output->proc_setBLANK(output, blank);
581
+
sm750_dev = par->dev;
582
+
583
+
if (sm750_dev->revid == SM750LE_REVISION_ID)
584
+
return hw_sm750le_set_blank(output, blank);
585
+
else
586
+
return hw_sm750_set_blank(output, blank);
581
587
}
582
588
583
589
static int sm750fb_set_drv(struct lynxfb_par *par)
···
604
598
crtc->vidmem_size >>= 1;
605
599
606
600
/* setup crtc and output member */
607
-
sm750_dev->hwCursor = g_hwcursor;
601
+
sm750_dev->hw_cursor = g_hwcursor;
608
602
609
603
crtc->line_pad = 16;
610
604
crtc->xpanstep = 8;
611
605
crtc->ypanstep = 1;
612
606
crtc->ywrapstep = 0;
613
607
614
-
output->proc_setBLANK = (sm750_dev->revid == SM750LE_REVISION_ID) ?
615
-
hw_sm750le_set_blank : hw_sm750_set_blank;
616
608
/* chip specific phase */
617
609
sm750_dev->accel.de_wait = (sm750_dev->revid == SM750LE_REVISION_ID) ?
618
610
hw_sm750le_de_wait : hw_sm750_de_wait;
+1
-3
drivers/staging/sm750fb/sm750.h
+1
-3
drivers/staging/sm750fb/sm750.h
···
113
113
* 2: secondary crtc hw cursor enabled
114
114
* 3: both ctrc hw cursor enabled
115
115
*/
116
-
int hwCursor;
116
+
int hw_cursor;
117
117
};
118
118
119
119
struct lynx_cursor {
···
169
169
* output->channel ==> &crtc->channel
170
170
*/
171
171
void *priv;
172
-
173
-
int (*proc_setBLANK)(struct lynxfb_output *output, int blank);
174
172
};
175
173
176
174
struct lynxfb_par {
+3
-3
drivers/staging/vme_user/vme.c
+3
-3
drivers/staging/vme_user/vme.c
···
809
809
* @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
810
810
* @route: Required src/destination combination.
811
811
*
812
-
* Request a VME DMA controller with capability to perform transfers bewteen
812
+
* Request a VME DMA controller with capability to perform transfers between
813
813
* requested source/destination combination.
814
814
*
815
815
* Return: Pointer to VME DMA resource on success, NULL on failure.
···
1045
1045
EXPORT_SYMBOL(vme_dma_free_attribute);
1046
1046
1047
1047
/**
1048
-
* vme_dma_list_add - Add enty to a VME DMA list.
1048
+
* vme_dma_list_add - Add entry to a VME DMA list.
1049
1049
* @list: Pointer to VME list.
1050
1050
* @src: Pointer to DMA list attribute to use as source.
1051
1051
* @dest: Pointer to DMA list attribute to use as destination.
···
1925
1925
1926
1926
static int vme_bus_match(struct device *dev, const struct device_driver *drv)
1927
1927
{
1928
-
struct vme_driver *vme_drv;
1928
+
const struct vme_driver *vme_drv;
1929
1929
1930
1930
vme_drv = container_of(drv, struct vme_driver, driver);
1931
1931
+1
-1
drivers/staging/vme_user/vme_fake.c
+1
-1
drivers/staging/vme_user/vme_fake.c
+1
-1
drivers/staging/vme_user/vme_tsi148.h
+1
-1
drivers/staging/vme_user/vme_tsi148.h
···
1347
1347
#define TSI148_GCSR_GCTRL_LRST BIT(15) /* Local Reset */
1348
1348
#define TSI148_GCSR_GCTRL_SFAILEN BIT(14) /* System Fail enable */
1349
1349
#define TSI148_GCSR_GCTRL_BDFAILS BIT(13) /* Board Fail Status */
1350
-
#define TSI148_GCSR_GCTRL_SCON BIT(12) /* System Copntroller */
1350
+
#define TSI148_GCSR_GCTRL_SCON BIT(12) /* System Controller */
1351
1351
#define TSI148_GCSR_GCTRL_MEN BIT(11) /* Module Enable (READY) */
1352
1352
1353
1353
#define TSI148_GCSR_GCTRL_LMI3S BIT(7) /* Loc Monitor 3 Int Status */