History

Merge branch 'staging-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging-2.6

* 'staging-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging-2.6: (28 commits) staging: usbip: bugfix for isochronous packets and optimization staging: usbip: bugfix add number of packets for isochronous frames staging: usbip: bugfixes related to kthread conversion staging: usbip: fix shutdown problems. staging: hv: Fix GARP not sent after Quick Migration staging: IIO: IMU: ADIS16400: Avoid using printk facility directly staging: IIO: IMU: ADIS16400: Fix product ID check, skip embedded revision number staging: IIO: IMU: ADIS16400: Make sure only enabled scan_elements are pushed into the ring staging: IIO: IMU: ADIS16400: Fix addresses of GYRO and ACCEL calibration offset staging: IIO: IMU: ADIS16400: Add delay after self test staging: IIO: IMU: ADIS16400: Fix up SPI messages cs_change behavior staging/rtl81*: build as loadable modules only staging: brcm80211: removed 'is_amsdu causing toss' log spam staging: brcm80211: fix for 'Short CCK' log spam staging: brcm80211: fix for 'AC_BE txop..' logs spammed problem staging: memrar: remove driver from tree staging: sep: remove last memrar remnants staging: fix hv_mouse build, needs delay.h staging: fix olpc_dcon build errors staging: sm7xx: fixed defines ... Fix up trivial conflict in drivers/staging/memrar/memrar_handler.c (deleted vs trivial spelling fixes)

Linus Torvalds committed 15 years ago

Commit df9b29d2 parents 7bc30c2 28276a240 files · +324 −2092Browse files

Unified · Split

40 files
  1. drivers/staging/Kconfig +0 −2
  2. drivers/staging/Makefile +0 −1
  3. drivers/staging/brcm80211/brcmsmac/wlc_main.c +3 −6
  4. drivers/staging/ft1000/ft1000-pcmcia/ft1000_dnld.c +39 −39
  5. drivers/staging/hv/channel.c +4 −4
  6. drivers/staging/hv/connection.c +2 −2
  7. drivers/staging/hv/hv_mouse.c +3 −2
  8. drivers/staging/hv/netvsc_drv.c +24 −0
  9. drivers/staging/hv/tools/hv_kvp_daemon.c +57 −33
  10. drivers/staging/hv/vmbus_drv.c +1 −1
  11. drivers/staging/hv/vmbus_private.h +1 −0
  12. drivers/staging/iio/imu/adis16400.h +2 −1
  13. drivers/staging/iio/imu/adis16400_core.c +10 −10
  14. drivers/staging/iio/imu/adis16400_ring.c +7 −5
  15. drivers/staging/memrar/Kconfig +0 −15
  16. drivers/staging/memrar/Makefile +0 −2
  17. drivers/staging/memrar/TODO +0 −43
  18. drivers/staging/memrar/memrar-abi +0 −89
  19. drivers/staging/memrar/memrar.h +0 −174
  20. drivers/staging/memrar/memrar_allocator.c +0 −432
  21. drivers/staging/memrar/memrar_allocator.h +0 −149
  22. drivers/staging/memrar/memrar_handler.c +0 −1007
  23. drivers/staging/olpc_dcon/Kconfig +1 −1
  24. drivers/staging/olpc_dcon/olpc_dcon_xo_1_5.c +1 −0
  25. drivers/staging/rtl8187se/Kconfig +1 −0
  26. drivers/staging/rtl8192e/Kconfig +1 −0
  27. drivers/staging/rtl8192u/Kconfig +1 −0
  28. drivers/staging/rts_pstor/rtsx.c +7 −7
  29. drivers/staging/rts_pstor/rtsx_chip.c +5 −6
  30. drivers/staging/sep/sep_driver.c +2 −13
  31. drivers/staging/sm7xx/smtcfb.c +2 −4
  32. drivers/staging/usbip/stub_dev.c +4 −2
  33. drivers/staging/usbip/stub_rx.c +15 −25
  34. drivers/staging/usbip/stub_tx.c +60 −14
  35. drivers/staging/usbip/usbip_common.c +63 −1
  36. drivers/staging/usbip/usbip_common.h +2 −0
  37. drivers/staging/usbip/vhci_rx.c +3 −0
  38. drivers/staging/vt6655/Kconfig +1 −1
  39. drivers/staging/vt6656/Kconfig +1 −1
  40. drivers/staging/westbridge/astoria/gadget/cyasgadget.c +1 −0
drivers/staging/Kconfig+0−2
@@ -117,8 +117,6 @@ source "drivers/staging/hv/Kconfig" · 116 unmodified lines
117117
118118 source "drivers/staging/vme/Kconfig"
119119
120−source "drivers/staging/memrar/Kconfig"
121−
122120 source "drivers/staging/sep/Kconfig"
123121
124122 source "drivers/staging/iio/Kconfig"
drivers/staging/Makefile+0−1
@@ -40,7 +40,6 @@ obj-$(CONFIG_VT6655) += vt6655/ · 39 unmodified lines
4040 obj-$(CONFIG_VT6656) += vt6656/
4141 obj-$(CONFIG_HYPERV) += hv/
4242 obj-$(CONFIG_VME_BUS) += vme/
43−obj-$(CONFIG_MRST_RAR_HANDLER) += memrar/
4443 obj-$(CONFIG_DX_SEP) += sep/
4544 obj-$(CONFIG_IIO) += iio/
4645 obj-$(CONFIG_CS5535_GPIO) += cs5535_gpio/
drivers/staging/brcm80211/brcmsmac/wlc_main.c+3−6
@@ -6283,7 +6283,7 @@ wlc_d11hdrs_mac80211(struct wlc_info *wlc, struct ieee80211_hw *hw, · 6282 unmodified lines
62836283 ((preamble_type[1] == WLC_MM_PREAMBLE) ==
62846284 (txh->MModeFbrLen != 0)));
62856285
6286− ac = wme_fifo2ac[queue];
6286+ ac = skb_get_queue_mapping(p);
62876287 if (SCB_WME(scb) && qos && wlc->edcf_txop[ac]) {
62886288 uint frag_dur, dur, dur_fallback;
62896289
@@ -6919,8 +6919,7 @@ prep_mac80211_status(struct wlc_info *wlc, d11rxhdr_t *rxh, struct sk_buff *p, · 629 unmodified lines
69196919 preamble = 0;
69206920 if (IS_CCK(rspec)) {
69216921 if (rxh->PhyRxStatus_0 & PRXS0_SHORTH)
6922− WL_ERROR("Short CCK\n");
6923− rx_status->flag |= RX_FLAG_SHORTPRE;
6922+ rx_status->flag |= RX_FLAG_SHORTPRE;
69246923 } else if (IS_OFDM(rspec)) {
69256924 rx_status->flag |= RX_FLAG_SHORTPRE;
69266925 } else {
@@ -7079,10 +7078,8 @@ void BCMFASTPATH wlc_recv(struct wlc_info *wlc, struct sk_buff *p) · 152 unmodified lines
70797078 if (ieee80211_is_probe_req(h->frame_control))
70807079 goto toss;
70817080
7082− if (is_amsdu) {
7083− WL_ERROR("%s: is_amsdu causing toss\n", __func__);
7081+ if (is_amsdu)
70847082 goto toss;
7085− }
70867083
70877084 wlc_recvctl(wlc, rxh, p);
70887085 return;
drivers/staging/ft1000/ft1000-pcmcia/ft1000_dnld.c+39−39
@@ -95,47 +95,47 @@ void put_request_value(struct net_device *dev, long lvalue); · 94 unmodified lines
9595 USHORT hdr_checksum(PPSEUDO_HDR pHdr);
9696
9797 typedef struct _DSP_FILE_HDR {
98− long build_date;
99− long dsp_coff_date;
100− long loader_code_address;
101− long loader_code_size;
102− long loader_code_end;
103− long dsp_code_address;
104− long dsp_code_size;
105− long dsp_code_end;
106− long reserved[8];
98+ u32 build_date;
99+ u32 dsp_coff_date;
100+ u32 loader_code_address;
101+ u32 loader_code_size;
102+ u32 loader_code_end;
103+ u32 dsp_code_address;
104+ u32 dsp_code_size;
105+ u32 dsp_code_end;
106+ u32 reserved[8];
107107 } __attribute__ ((packed)) DSP_FILE_HDR, *PDSP_FILE_HDR;
108108
109109 typedef struct _DSP_FILE_HDR_5 {
110− long version_id; // Version ID of this image format.
111− long package_id; // Package ID of code release.
112− long build_date; // Date/time stamp when file was built.
113− long commands_offset; // Offset to attached commands in Pseudo Hdr format.
114− long loader_offset; // Offset to bootloader code.
115− long loader_code_address; // Start address of bootloader.
116− long loader_code_end; // Where bootloader code ends.
117− long loader_code_size;
118− long version_data_offset; // Offset were scrambled version data begins.
119− long version_data_size; // Size, in words, of scrambled version data.
120− long nDspImages; // Number of DSP images in file.
110+ u32 version_id; // Version ID of this image format.
111+ u32 package_id; // Package ID of code release.
112+ u32 build_date; // Date/time stamp when file was built.
113+ u32 commands_offset; // Offset to attached commands in Pseudo Hdr format.
114+ u32 loader_offset; // Offset to bootloader code.
115+ u32 loader_code_address; // Start address of bootloader.
116+ u32 loader_code_end; // Where bootloader code ends.
117+ u32 loader_code_size;
118+ u32 version_data_offset; // Offset were scrambled version data begins.
119+ u32 version_data_size; // Size, in words, of scrambled version data.
120+ u32 nDspImages; // Number of DSP images in file.
121121 } __attribute__ ((packed)) DSP_FILE_HDR_5, *PDSP_FILE_HDR_5;
122122
123123 typedef struct _DSP_IMAGE_INFO {
124− long coff_date; // Date/time when DSP Coff image was built.
125− long begin_offset; // Offset in file where image begins.
126− long end_offset; // Offset in file where image begins.
127− long run_address; // On chip Start address of DSP code.
128− long image_size; // Size of image.
129− long version; // Embedded version # of DSP code.
124+ u32 coff_date; // Date/time when DSP Coff image was built.
125+ u32 begin_offset; // Offset in file where image begins.
126+ u32 end_offset; // Offset in file where image begins.
127+ u32 run_address; // On chip Start address of DSP code.
128+ u32 image_size; // Size of image.
129+ u32 version; // Embedded version # of DSP code.
130130 } __attribute__ ((packed)) DSP_IMAGE_INFO, *PDSP_IMAGE_INFO;
131131
132132 typedef struct _DSP_IMAGE_INFO_V6 {
133− long coff_date; // Date/time when DSP Coff image was built.
134− long begin_offset; // Offset in file where image begins.
135− long end_offset; // Offset in file where image begins.
136− long run_address; // On chip Start address of DSP code.
137− long image_size; // Size of image.
138− long version; // Embedded version # of DSP code.
133+ u32 coff_date; // Date/time when DSP Coff image was built.
134+ u32 begin_offset; // Offset in file where image begins.
135+ u32 end_offset; // Offset in file where image begins.
136+ u32 run_address; // On chip Start address of DSP code.
137+ u32 image_size; // Size of image.
138+ u32 version; // Embedded version # of DSP code.
139139 unsigned short checksum; // Dsp File checksum
140140 unsigned short pad1;
141141 } __attribute__ ((packed)) DSP_IMAGE_INFO_V6, *PDSP_IMAGE_INFO_V6;
@@ -846,8 +846,8 @@ int card_download(struct net_device *dev, const u8 *pFileStart, UINT FileLength) · 704 unmodified lines
846846 break;
847847
848848 case STATE_DONE_DWNLD:
849− if (((UINT) (pUcFile) - (UINT) pFileStart) >=
850− (UINT) FileLength) {
849+ if (((unsigned long) (pUcFile) - (unsigned long) pFileStart) >=
850+ (unsigned long) FileLength) {
851851 uiState = STATE_DONE_FILE;
852852 break;
853853 }
@@ -901,11 +901,11 @@ int card_download(struct net_device *dev, const u8 *pFileStart, UINT FileLength) · 47 unmodified lines
901901 &info->prov_list);
902902 // Move to next entry if available
903903 pUcFile =
904− (UCHAR *) ((UINT) pUcFile +
905− (UINT) ((usHdrLength + 1) & 0xFFFFFFFE) + sizeof(PSEUDO_HDR));
906− if ((UINT) (pUcFile) -
907− (UINT) (pFileStart) >=
908− (UINT) FileLength) {
904+ (UCHAR *) ((unsigned long) pUcFile +
905+ (unsigned long) ((usHdrLength + 1) & 0xFFFFFFFE) + sizeof(PSEUDO_HDR));
906+ if ((unsigned long) (pUcFile) -
907+ (unsigned long) (pFileStart) >=
908+ (unsigned long) FileLength) {
909909 uiState =
910910 STATE_DONE_FILE;
911911 }
drivers/staging/hv/channel.c+4−4
@@ -81,14 +81,14 @@ static void vmbus_setevent(struct vmbus_channel *channel) · 80 unmodified lines
8181
8282 if (channel->offermsg.monitor_allocated) {
8383 /* Each u32 represents 32 channels */
84− set_bit(channel->offermsg.child_relid & 31,
84+ sync_set_bit(channel->offermsg.child_relid & 31,
8585 (unsigned long *) vmbus_connection.send_int_page +
8686 (channel->offermsg.child_relid >> 5));
8787
8888 monitorpage = vmbus_connection.monitor_pages;
8989 monitorpage++; /* Get the child to parent monitor page */
9090
91− set_bit(channel->monitor_bit,
91+ sync_set_bit(channel->monitor_bit,
9292 (unsigned long *)&monitorpage->trigger_group
9393 [channel->monitor_grp].pending);
9494
@@ -104,7 +104,7 @@ static void VmbusChannelClearEvent(struct vmbus_channel *channel) · 9 unmodified lines
104104
105105 if (Channel->offermsg.monitor_allocated) {
106106 /* Each u32 represents 32 channels */
107− clear_bit(Channel->offermsg.child_relid & 31,
107+ sync_clear_bit(Channel->offermsg.child_relid & 31,
108108 (unsigned long *)vmbus_connection.send_int_page +
109109 (Channel->offermsg.child_relid >> 5));
110110
@@ -112,7 +112,7 @@ static void VmbusChannelClearEvent(struct vmbus_channel *channel) · 1 unmodified line
112112 vmbus_connection.monitor_pages;
113113 monitorPage++; /* Get the child to parent monitor page */
114114
115− clear_bit(Channel->monitor_bit,
115+ sync_clear_bit(Channel->monitor_bit,
116116 (unsigned long *)&monitorPage->trigger_group
117117 [Channel->monitor_grp].Pending);
118118 }
drivers/staging/hv/connection.c+2−2
@@ -296,7 +296,7 @@ void vmbus_on_event(unsigned long data) · 295 unmodified lines
296296 for (dword = 0; dword < maxdword; dword++) {
297297 if (recv_int_page[dword]) {
298298 for (bit = 0; bit < 32; bit++) {
299− if (test_and_clear_bit(bit,
299+ if (sync_test_and_clear_bit(bit,
300300 (unsigned long *)
301301 &recv_int_page[dword])) {
302302 relid = (dword << 5) + bit;
@@ -338,7 +338,7 @@ int vmbus_post_msg(void *buffer, size_t buflen) · 35 unmodified lines
338338 int vmbus_set_event(u32 child_relid)
339339 {
340340 /* Each u32 represents 32 channels */
341− set_bit(child_relid & 31,
341+ sync_set_bit(child_relid & 31,
342342 (unsigned long *)vmbus_connection.send_int_page +
343343 (child_relid >> 5));
344344
drivers/staging/hv/hv_mouse.c+3−2
@@ -14,6 +14,7 @@ · 13 unmodified lines
1414 */
1515 #include <linux/init.h>
1616 #include <linux/module.h>
17+#include <linux/delay.h>
1718 #include <linux/device.h>
1819 #include <linux/workqueue.h>
1920 #include <linux/sched.h>
@@ -375,7 +376,7 @@ static void MousevscOnReceiveDeviceInfo(struct mousevsc_dev *InputDevice, struct · 355 unmodified lines
375376 desc->desc[0].wDescriptorLength);
376377
377378 /* Send the ack */
378− memset(&ack, sizeof(struct mousevsc_prt_msg), 0);
379+ memset(&ack, 0, sizeof(struct mousevsc_prt_msg));
379380
380381 ack.type = PipeMessageData;
381382 ack.size = sizeof(struct synthhid_device_info_ack);
@@ -596,7 +597,7 @@ static int MousevscConnectToVsp(struct hv_device *Device) · 214 unmodified lines
596597 /*
597598 * Now, initiate the vsc/vsp initialization protocol on the open channel
598599 */
599− memset(request, sizeof(struct mousevsc_prt_msg), 0);
600+ memset(request, 0, sizeof(struct mousevsc_prt_msg));
600601
601602 request->type = PipeMessageData;
602603 request->size = sizeof(struct synthhid_protocol_request);
drivers/staging/hv/netvsc_drv.c+24−0
@@ -46,6 +46,7 @@ struct net_device_context { · 45 unmodified lines
4646 /* point back to our device context */
4747 struct hv_device *device_ctx;
4848 unsigned long avail;
49+ struct work_struct work;
4950 };
5051
5152
@@ -219,6 +220,7 @@ static void netvsc_linkstatus_callback(struct hv_device *device_obj, · 167 unmodified lines
219220 unsigned int status)
220221 {
221222 struct net_device *net = dev_get_drvdata(&device_obj->device);
223+ struct net_device_context *ndev_ctx;
222224
223225 if (!net) {
224226 DPRINT_ERR(NETVSC_DRV, "got link status but net device "
@@ -230,6 +232,8 @@ static void netvsc_linkstatus_callback(struct hv_device *device_obj, · 5 unmodified lines
230232 netif_carrier_on(net);
231233 netif_wake_queue(net);
232234 netif_notify_peers(net);
235+ ndev_ctx = netdev_priv(net);
236+ schedule_work(&ndev_ctx->work);
233237 } else {
234238 netif_carrier_off(net);
235239 netif_stop_queue(net);
@@ -328,6 +332,25 @@ static const struct net_device_ops device_ops = { · 92 unmodified lines
328332 .ndo_set_mac_address = eth_mac_addr,
329333 };
330334
335+/*
336+ * Send GARP packet to network peers after migrations.
337+ * After Quick Migration, the network is not immediately operational in the
338+ * current context when receiving RNDIS_STATUS_MEDIA_CONNECT event. So, add
339+ * another netif_notify_peers() into a scheduled work, otherwise GARP packet
340+ * will not be sent after quick migration, and cause network disconnection.
341+ */
342+static void netvsc_send_garp(struct work_struct *w)
343+{
344+ struct net_device_context *ndev_ctx;
345+ struct net_device *net;
346+
347+ msleep(20);
348+ ndev_ctx = container_of(w, struct net_device_context, work);
349+ net = dev_get_drvdata(&ndev_ctx->device_ctx->device);
350+ netif_notify_peers(net);
351+}
352+
353+
331354 static int netvsc_probe(struct device *device)
332355 {
333356 struct hv_driver *drv =
@@ -353,6 +376,7 @@ static int netvsc_probe(struct device *device) · 19 unmodified lines
353376 net_device_ctx->device_ctx = device_obj;
354377 net_device_ctx->avail = ring_size;
355378 dev_set_drvdata(device, net);
379+ INIT_WORK(&net_device_ctx->work, netvsc_send_garp);
356380
357381 /* Notify the netvsc driver of the new device */
358382 ret = net_drv_obj->base.dev_add(device_obj, &device_info);
drivers/staging/hv/tools/hv_kvp_daemon.c+57−33
@@ -102,22 +102,22 @@ static char kvp_send_buffer[4096]; · 101 unmodified lines
102102 static char kvp_recv_buffer[4096];
103103 static struct sockaddr_nl addr;
104104
105−static char os_name[100];
106−static char os_major[50];
107−static char os_minor[50];
108−static char processor_arch[50];
109−static char os_build[100];
105+static char *os_name = "";
106+static char *os_major = "";
107+static char *os_minor = "";
108+static char *processor_arch;
109+static char *os_build;
110110 static char *lic_version;
111+static struct utsname uts_buf;
111112
112113 void kvp_get_os_info(void)
113114 {
114115 FILE *file;
115− char *eol;
116− struct utsname buf;
116+ char *p, buf[512];
117117
118− uname(&buf);
119− strcpy(os_build, buf.release);
120− strcpy(processor_arch, buf.machine);
118+ uname(&uts_buf);
119+ os_build = uts_buf.release;
120+ processor_arch= uts_buf.machine;
121121
122122 file = fopen("/etc/SuSE-release", "r");
123123 if (file != NULL)
@@ -132,21 +132,46 @@ void kvp_get_os_info(void) · 8 unmodified lines
132132 /*
133133 * We don't have information about the os.
134134 */
135− strcpy(os_name, "Linux");
136− strcpy(os_major, "0");
137− strcpy(os_minor, "0");
135+ os_name = uts_buf.sysname;
138136 return;
139137
140138 kvp_osinfo_found:
141− fgets(os_name, 99, file);
142− eol = index(os_name, '\n');
143− *eol = '\0';
144− fgets(os_major, 49, file);
145− eol = index(os_major, '\n');
146− *eol = '\0';
147− fgets(os_minor, 49, file);
148− eol = index(os_minor, '\n');
149− *eol = '\0';
139+ /* up to three lines */
140+ p = fgets(buf, sizeof(buf), file);
141+ if (p) {
142+ p = strchr(buf, '\n');
143+ if (p)
144+ *p = '\0';
145+ p = strdup(buf);
146+ if (!p)
147+ goto done;
148+ os_name = p;
149+
150+ /* second line */
151+ p = fgets(buf, sizeof(buf), file);
152+ if (p) {
153+ p = strchr(buf, '\n');
154+ if (p)
155+ *p = '\0';
156+ p = strdup(buf);
157+ if (!p)
158+ goto done;
159+ os_major = p;
160+
161+ /* third line */
162+ p = fgets(buf, sizeof(buf), file);
163+ if (p) {
164+ p = strchr(buf, '\n');
165+ if (p)
166+ *p = '\0';
167+ p = strdup(buf);
168+ if (p)
169+ os_minor = p;
170+ }
171+ }
172+ }
173+
174+done:
150175 fclose(file);
151176 return;
152177 }
@@ -293,7 +318,7 @@ netlink_send(int fd, struct cn_msg *msg) · 140 unmodified lines
293318 return sendmsg(fd, &message, 0);
294319 }
295320
296−main(void)
321+int main(void)
297322 {
298323 int fd, len, sock_opt;
299324 int error;
@@ -301,9 +326,10 @@ main(void) · 1 unmodified line
301326 struct pollfd pfd;
302327 struct nlmsghdr *incoming_msg;
303328 struct cn_msg *incoming_cn_msg;
329+ struct hv_ku_msg *hv_msg;
330+ char *p;
304331 char *key_value;
305332 char *key_name;
306− int key_index;
307333
308334 daemon(1, 0);
309335 openlog("KVP", 0, LOG_USER);
@@ -373,9 +399,10 @@ main(void) · 63 unmodified lines
373399 * Driver is registering with us; stash away the version
374400 * information.
375401 */
376− lic_version = malloc(strlen(incoming_cn_msg->data) + 1);
402+ p = (char *)incoming_cn_msg->data;
403+ lic_version = malloc(strlen(p) + 1);
377404 if (lic_version) {
378− strcpy(lic_version, incoming_cn_msg->data);
405+ strcpy(lic_version, p);
379406 syslog(LOG_INFO, "KVP LIC Version: %s",
380407 lic_version);
381408 } else {
@@ -389,14 +416,11 @@ main(void) · 7 unmodified lines
389416 continue;
390417 }
391418
392− key_index =
393− ((struct hv_ku_msg *)incoming_cn_msg->data)->kvp_index;
394− key_name =
395− ((struct hv_ku_msg *)incoming_cn_msg->data)->kvp_key;
396− key_value =
397− ((struct hv_ku_msg *)incoming_cn_msg->data)->kvp_value;
419+ hv_msg = (struct hv_ku_msg *)incoming_cn_msg->data;
420+ key_name = (char *)hv_msg->kvp_key;
421+ key_value = (char *)hv_msg->kvp_value;
398422
399− switch (key_index) {
423+ switch (hv_msg->kvp_index) {
400424 case FullyQualifiedDomainName:
401425 kvp_get_domain_name(key_value,
402426 HV_KVP_EXCHANGE_MAX_VALUE_SIZE);
drivers/staging/hv/vmbus_drv.c+1−1
@@ -254,7 +254,7 @@ static int vmbus_on_isr(void) · 253 unmodified lines
254254 event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT;
255255
256256 /* Since we are a child, we only need to check bit 0 */
257− if (test_and_clear_bit(0, (unsigned long *) &event->flags32[0])) {
257+ if (sync_test_and_clear_bit(0, (unsigned long *) &event->flags32[0])) {
258258 DPRINT_DBG(VMBUS, "received event %d", event->flags32[0]);
259259 ret |= 0x2;
260260 }
drivers/staging/hv/vmbus_private.h+1−0
@@ -31,6 +31,7 @@ · 30 unmodified lines
3131 #include "channel_mgmt.h"
3232 #include "ring_buffer.h"
3333 #include <linux/list.h>
34+#include <asm/sync_bitops.h>
3435
3536
3637 /*
drivers/staging/iio/imu/adis16400.h+2−1
@@ -17,7 +17,8 @@ · 16 unmodified lines
1717 #ifndef SPI_ADIS16400_H_
1818 #define SPI_ADIS16400_H_
1919
20−#define ADIS16400_STARTUP_DELAY 220 /* ms */
20+#define ADIS16400_STARTUP_DELAY 290 /* ms */
21+#define ADIS16400_MTEST_DELAY 90 /* ms */
2122
2223 #define ADIS16400_READ_REG(a) a
2324 #define ADIS16400_WRITE_REG(a) ((a) | 0x80)
drivers/staging/iio/imu/adis16400_core.c+10−10
@@ -6,6 +6,7 @@ · 5 unmodified lines
66 *
77 * Copyright (c) 2009 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
88 * Copyright (c) 2007 Jonathan Cameron <jic23@cam.ac.uk>
9+ * Copyright (c) 2011 Analog Devices Inc.
910 *
1011 * This program is free software; you can redistribute it and/or modify
1112 * it under the terms of the GNU General Public License version 2 as
@@ -93,7 +94,6 @@ static int adis16400_spi_write_reg_16(struct device *dev, · 81 unmodified lines
9394 .tx_buf = st->tx + 2,
9495 .bits_per_word = 8,
9596 .len = 2,
96− .cs_change = 1,
9797 },
9898 };
9999
@@ -137,7 +137,6 @@ static int adis16400_spi_read_reg_16(struct device *dev, · 37 unmodified lines
137137 .rx_buf = st->rx,
138138 .bits_per_word = 8,
139139 .len = 2,
140− .cs_change = 1,
141140 },
142141 };
143142
@@ -375,7 +374,7 @@ static int adis16400_self_test(struct device *dev) · 231 unmodified lines
375374 dev_err(dev, "problem starting self test");
376375 goto err_ret;
377376 }
378−
377+ msleep(ADIS16400_MTEST_DELAY);
379378 adis16400_check_status(dev);
380379
381380 err_ret:
@@ -471,10 +470,11 @@ static int adis16400_initial_setup(struct adis16400_state *st) · 89 unmodified lines
471470 if (ret)
472471 goto err_ret;
473472
474− if (prod_id != ADIS16400_PRODUCT_ID_DEFAULT)
473+ if ((prod_id & 0xF000) != ADIS16400_PRODUCT_ID_DEFAULT)
475474 dev_warn(dev, "unknown product id");
476475
477− printk(KERN_INFO DRIVER_NAME ": prod_id 0x%04x at CS%d (irq %d)\n",
476+
477+ dev_info(dev, ": prod_id 0x%04x at CS%d (irq %d)\n",
478478 prod_id, st->us->chip_select, st->us->irq);
479479
480480 /* use high spi speed if possible */
@@ -497,12 +497,12 @@ err_ret: · 16 unmodified lines
497497 _reg)
498498
499499 static ADIS16400_DEV_ATTR_CALIBBIAS(GYRO_X, ADIS16400_XGYRO_OFF);
500−static ADIS16400_DEV_ATTR_CALIBBIAS(GYRO_Y, ADIS16400_XGYRO_OFF);
501−static ADIS16400_DEV_ATTR_CALIBBIAS(GYRO_Z, ADIS16400_XGYRO_OFF);
500+static ADIS16400_DEV_ATTR_CALIBBIAS(GYRO_Y, ADIS16400_YGYRO_OFF);
501+static ADIS16400_DEV_ATTR_CALIBBIAS(GYRO_Z, ADIS16400_ZGYRO_OFF);
502502
503503 static ADIS16400_DEV_ATTR_CALIBBIAS(ACCEL_X, ADIS16400_XACCL_OFF);
504−static ADIS16400_DEV_ATTR_CALIBBIAS(ACCEL_Y, ADIS16400_XACCL_OFF);
505−static ADIS16400_DEV_ATTR_CALIBBIAS(ACCEL_Z, ADIS16400_XACCL_OFF);
504+static ADIS16400_DEV_ATTR_CALIBBIAS(ACCEL_Y, ADIS16400_YACCL_OFF);
505+static ADIS16400_DEV_ATTR_CALIBBIAS(ACCEL_Z, ADIS16400_ZACCL_OFF);
506506
507507
508508 static IIO_DEV_ATTR_IN_NAMED_RAW(0, supply, adis16400_read_14bit_signed,
@@ -647,7 +647,7 @@ static int __devinit adis16400_probe(struct spi_device *spi) · 138 unmodified lines
647647
648648 ret = iio_ring_buffer_register(st->indio_dev->ring, 0);
649649 if (ret) {
650− printk(KERN_ERR "failed to initialize the ring\n");
650+ dev_err(&spi->dev, "failed to initialize the ring\n");
651651 goto error_unreg_ring_funcs;
652652 }
653653
drivers/staging/iio/imu/adis16400_ring.c+7−5
@@ -122,12 +122,10 @@ static int adis16400_spi_read_burst(struct device *dev, u8 *rx) · 121 unmodified lines
122122 .tx_buf = st->tx,
123123 .bits_per_word = 8,
124124 .len = 2,
125− .cs_change = 0,
126125 }, {
127126 .rx_buf = rx,
128127 .bits_per_word = 8,
129128 .len = 24,
130− .cs_change = 1,
131129 },
132130 };
133131
@@ -162,9 +160,10 @@ static void adis16400_trigger_bh_to_ring(struct work_struct *work_s) · 28 unmodified lines
162160 work_trigger_to_ring);
163161 struct iio_ring_buffer *ring = st->indio_dev->ring;
164162
165− int i = 0;
163+ int i = 0, j;
166164 s16 *data;
167165 size_t datasize = ring->access.get_bytes_per_datum(ring);
166+ unsigned long mask = ring->scan_mask;
168167
169168 data = kmalloc(datasize , GFP_KERNEL);
170169 if (data == NULL) {
@@ -174,9 +173,12 @@ static void adis16400_trigger_bh_to_ring(struct work_struct *work_s) · 3 unmodified lines
174173
175174 if (ring->scan_count)
176175 if (adis16400_spi_read_burst(&st->indio_dev->dev, st->rx) >= 0)
177− for (; i < ring->scan_count; i++)
176+ for (; i < ring->scan_count; i++) {
177+ j = __ffs(mask);
178+ mask &= ~(1 << j);
178179 data[i] = be16_to_cpup(
179− (__be16 *)&(st->rx[i*2]));
180+ (__be16 *)&(st->rx[j*2]));
181+ }
180182
181183 /* Guaranteed to be aligned with 8 byte boundary */
182184 if (ring->scan_timestamp)
drivers/staging/memrar/Kconfig+0−15
@@ -1,15 +0,0 @@
1−config MRST_RAR_HANDLER
2− tristate "RAR handler driver for Intel Moorestown platform"
3− depends on RAR_REGISTER
4− ---help---
5− This driver provides a memory management interface to
6− restricted access regions (RAR) available on the Intel
7− Moorestown platform.
8−
9− Once locked down, restricted access regions are only
10− accessible by specific hardware on the platform. The x86
11− CPU is typically not one of those platforms. As such this
12− driver does not access RAR, and only provides a buffer
13− allocation/bookkeeping mechanism.
14−
15− If unsure, say N.
drivers/staging/memrar/Makefile+0−2
@@ -1,2 +0,0 @@
1−obj-$(CONFIG_MRST_RAR_HANDLER) += memrar.o
2−memrar-y := memrar_allocator.o memrar_handler.o
drivers/staging/memrar/TODO+0−43
@@ -1,43 +0,0 @@
1−RAR Handler (memrar) Driver TODO Items
2−======================================
3−
4−Maintainer: Eugene Epshteyn <eugene.epshteyn@intel.com>
5−
6−memrar.h
7−--------
8−1. This header exposes the driver's user space and kernel space
9− interfaces. It should be moved to <linux/rar/memrar.h>, or
10− something along those lines, when this memrar driver is moved out
11− of `staging'.
12− a. It would be ideal if staging/rar_register/rar_register.h was
13− moved to the same directory.
14−
15−memrar_allocator.[ch]
16−---------------------
17−1. Address potential fragmentation issues with the memrar_allocator.
18−
19−2. Hide struct memrar_allocator details/fields. They need not be
20− exposed to the user.
21− a. Forward declare struct memrar_allocator.
22− b. Move all three struct definitions to `memrar_allocator.c'
23− source file.
24− c. Add a memrar_allocator_largest_free_area() function, or
25− something like that to get access to the value of the struct
26− memrar_allocator "largest_free_area" field. This allows the
27− struct memrar_allocator fields to be completely hidden from
28− the user. The memrar_handler code really only needs this for
29− statistic gathering on-demand.
30− d. Do the same for the "capacity" field as the
31− "largest_free_area" field.
32−
33−3. Move memrar_allocator.* to kernel `lib' directory since it is HW
34− neutral.
35− a. Alternatively, use lib/genalloc.c instead.
36− b. A kernel port of Doug Lea's malloc() implementation may also
37− be an option.
38−
39−memrar_handler.c
40−----------------
41−1. Split user space interface (ioctl code) from core/kernel code,
42− e.g.:
43− memrar_handler.c -> memrar_core.c, memrar_user.c
drivers/staging/memrar/memrar-abi+0−89
@@ -1,89 +0,0 @@
1−What: /dev/memrar
2−Date: March 2010
3−KernelVersion: 2.6.34
4−Contact: Eugene Epshteyn <eugene.epshteyn@intel.com>
5−Description: The Intel Moorestown Restricted Access Region (RAR)
6− Handler driver exposes an ioctl() based interface that
7− allows a user to reserve and release blocks of RAR
8− memory.
9−
10− Note: A sysfs based one was not appropriate for the
11− RAR handler's usage model.
12−
13− =========================================================
14− ioctl() Requests
15− =========================================================
16− RAR_HANDLER_RESERVE
17− -------------------
18− Description: Reserve RAR block.
19− Type: struct RAR_block_info
20− Direction: in/out
21− Errors: EINVAL (invalid RAR type or size)
22− ENOMEM (not enough RAR memory)
23−
24− RAR_HANDLER_STAT
25− ----------------
26− Description: Get RAR statistics.
27− Type: struct RAR_stat
28− Direction: in/out
29− Errors: EINVAL (invalid RAR type)
30−
31− RAR_HANDLER_RELEASE
32− -------------------
33− Description: Release previously reserved RAR block.
34− Type: 32 bit unsigned integer
35− (e.g. uint32_t), i.e the RAR "handle".
36− Direction: in
37− Errors: EINVAL (invalid RAR handle)
38−
39−
40− =========================================================
41− ioctl() Request Parameter Types
42− =========================================================
43− The structures referred to above are defined as
44− follows:
45−
46− /**
47− * struct RAR_block_info - user space struct that
48− * describes RAR buffer
49− * @type: Type of RAR memory (e.g.,
50− * RAR_TYPE_VIDEO or RAR_TYPE_AUDIO) [in]
51− * @size: Requested size of a block in bytes to
52− * be reserved in RAR. [in]
53− * @handle: Handle that can be used to refer to
54− * reserved block. [out]
55− *
56− * This is the basic structure exposed to the user
57− * space that describes a given RAR buffer. It used
58− * as the parameter for the RAR_HANDLER_RESERVE ioctl.
59− * The buffer's underlying bus address is not exposed
60− * to the user. User space code refers to the buffer
61− * entirely by "handle".
62− */
63− struct RAR_block_info {
64− __u32 type;
65− __u32 size;
66− __u32 handle;
67− };
68−
69− /**
70− * struct RAR_stat - RAR statistics structure
71− * @type: Type of RAR memory (e.g.,
72− * RAR_TYPE_VIDEO or
73− * RAR_TYPE_AUDIO) [in]
74− * @capacity: Total size of RAR memory
75− * region. [out]
76− * @largest_block_size: Size of the largest reservable
77− * block. [out]
78− *
79− * This structure is used for RAR_HANDLER_STAT ioctl.
80− */
81− struct RAR_stat {
82− __u32 type;
83− __u32 capacity;
84− __u32 largest_block_size;
85− };
86−
87− Lastly, the RAR_HANDLER_RELEASE ioctl expects a
88− "handle" to the RAR block of memory. It is a 32 bit
89− unsigned integer.
drivers/staging/memrar/memrar.h+0−174
@@ -1,174 +0,0 @@
1−/*
2− * RAR Handler (/dev/memrar) internal driver API.
3− * Copyright (C) 2010 Intel Corporation. All rights reserved.
4− *
5− * This program is free software; you can redistribute it and/or
6− * modify it under the terms of version 2 of the GNU General
7− * Public License as published by the Free Software Foundation.
8− *
9− * This program is distributed in the hope that it will be
10− * useful, but WITHOUT ANY WARRANTY; without even the implied
11− * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12− * PURPOSE. See the GNU General Public License for more details.
13− * You should have received a copy of the GNU General Public
14− * License along with this program; if not, write to the Free
15− * Software Foundation, Inc., 59 Temple Place - Suite 330,
16− * Boston, MA 02111-1307, USA.
17− * The full GNU General Public License is included in this
18− * distribution in the file called COPYING.
19− */
20−
21−
22−#ifndef _MEMRAR_H
23−#define _MEMRAR_H
24−
25−#include <linux/ioctl.h>
26−#include <linux/types.h>
27−
28−
29−/**
30− * struct RAR_stat - RAR statistics structure
31− * @type: Type of RAR memory (e.g., audio vs. video)
32− * @capacity: Total size of RAR memory region.
33− * @largest_block_size: Size of the largest reservable block.
34− *
35− * This structure is used for RAR_HANDLER_STAT ioctl and for the
36− * RAR_get_stat() user space wrapper function.
37− */
38−struct RAR_stat {
39− __u32 type;
40− __u32 capacity;
41− __u32 largest_block_size;
42−};
43−
44−
45−/**
46− * struct RAR_block_info - user space struct that describes RAR buffer
47− * @type: Type of RAR memory (e.g., audio vs. video)
48− * @size: Requested size of a block to be reserved in RAR.
49− * @handle: Handle that can be used to refer to reserved block.
50− *
51− * This is the basic structure exposed to the user space that
52− * describes a given RAR buffer. The buffer's underlying bus address
53− * is not exposed to the user. User space code refers to the buffer
54− * entirely by "handle".
55− */
56−struct RAR_block_info {
57− __u32 type;
58− __u32 size;
59− __u32 handle;
60−};
61−
62−
63−#define RAR_IOCTL_BASE 0xE0
64−
65−/* Reserve RAR block. */
66−#define RAR_HANDLER_RESERVE _IOWR(RAR_IOCTL_BASE, 0x00, struct RAR_block_info)
67−
68−/* Release previously reserved RAR block. */
69−#define RAR_HANDLER_RELEASE _IOW(RAR_IOCTL_BASE, 0x01, __u32)
70−
71−/* Get RAR stats. */
72−#define RAR_HANDLER_STAT _IOWR(RAR_IOCTL_BASE, 0x02, struct RAR_stat)
73−
74−
75−#ifdef __KERNEL__
76−
77−/* -------------------------------------------------------------- */
78−/* Kernel Side RAR Handler Interface */
79−/* -------------------------------------------------------------- */
80−
81−/**
82− * struct RAR_buffer - kernel space struct that describes RAR buffer
83− * @info: structure containing base RAR buffer information
84− * @bus_address: buffer bus address
85− *
86− * Structure that contains all information related to a given block of
87− * memory in RAR. It is generally only used when retrieving RAR
88− * related bus addresses.
89− *
90− * Note: This structure is used only by RAR-enabled drivers, and is
91− * not intended to be exposed to the user space.
92− */
93−struct RAR_buffer {
94− struct RAR_block_info info;
95− dma_addr_t bus_address;
96−};
97−
98−#if defined(CONFIG_MRST_RAR_HANDLER)
99−/**
100− * rar_reserve() - reserve RAR buffers
101− * @buffers: array of RAR_buffers where type and size of buffers to
102− * reserve are passed in, handle and bus address are
103− * passed out
104− * @count: number of RAR_buffers in the "buffers" array
105− *
106− * This function will reserve buffers in the restricted access regions
107− * of given types.
108− *
109− * It returns the number of successfully reserved buffers. Successful
110− * buffer reservations will have the corresponding bus_address field
111− * set to a non-zero value in the given buffers vector.
112− */
113−extern size_t rar_reserve(struct RAR_buffer *buffers,
114− size_t count);
115−
116−/**
117− * rar_release() - release RAR buffers
118− * @buffers: array of RAR_buffers where handles to buffers to be
119− * released are passed in
120− * @count: number of RAR_buffers in the "buffers" array
121− *
122− * This function will release RAR buffers that were retrieved through
123− * a call to rar_reserve() or rar_handle_to_bus() by decrementing the
124− * reference count. The RAR buffer will be reclaimed when the
125− * reference count drops to zero.
126− *
127− * It returns the number of successfully released buffers. Successful
128− * releases will have their handle field set to zero in the given
129− * buffers vector.
130− */
131−extern size_t rar_release(struct RAR_buffer *buffers,
132− size_t count);
133−
134−/**
135− * rar_handle_to_bus() - convert a vector of RAR handles to bus addresses
136− * @buffers: array of RAR_buffers containing handles to be
137− * converted to bus_addresses
138− * @count: number of RAR_buffers in the "buffers" array
139−
140− * This function will retrieve the RAR buffer bus addresses, type and
141− * size corresponding to the RAR handles provided in the buffers
142− * vector.
143− *
144− * It returns the number of successfully converted buffers. The bus
145− * address will be set to 0 for unrecognized handles.
146− *
147− * The reference count for each corresponding buffer in RAR will be
148− * incremented. Call rar_release() when done with the buffers.
149− */
150−extern size_t rar_handle_to_bus(struct RAR_buffer *buffers,
151− size_t count);
152−
153−#else
154−
155−extern inline size_t rar_reserve(struct RAR_buffer *buffers, size_t count)
156−{
157− return 0;
158−}
159−
160−extern inline size_t rar_release(struct RAR_buffer *buffers, size_t count)
161−{
162− return 0;
163−}
164−
165−extern inline size_t rar_handle_to_bus(struct RAR_buffer *buffers,
166− size_t count)
167−{
168− return 0;
169−}
170−
171−#endif /* MRST_RAR_HANDLER */
172−#endif /* __KERNEL__ */
173−
174−#endif /* _MEMRAR_H */
drivers/staging/memrar/memrar_allocator.c+0−432
@@ -1,432 +0,0 @@
1−/*
2− * memrar_allocator 1.0: An allocator for Intel RAR.
3− *
4− * Copyright (C) 2010 Intel Corporation. All rights reserved.
5− *
6− * This program is free software; you can redistribute it and/or
7− * modify it under the terms of version 2 of the GNU General
8− * Public License as published by the Free Software Foundation.
9− *
10− * This program is distributed in the hope that it will be
11− * useful, but WITHOUT ANY WARRANTY; without even the implied
12− * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
13− * PURPOSE. See the GNU General Public License for more details.
14− * You should have received a copy of the GNU General Public
15− * License along with this program; if not, write to the Free
16− * Software Foundation, Inc., 59 Temple Place - Suite 330,
17− * Boston, MA 02111-1307, USA.
18− * The full GNU General Public License is included in this
19− * distribution in the file called COPYING.
20− *
21− *
22− * ------------------------------------------------------------------
23− *
24− * This simple allocator implementation provides a
25− * malloc()/free()-like interface for reserving space within a
26− * previously reserved block of memory. It is not specific to
27− * any hardware, nor is it coupled with the lower level paging
28− * mechanism.
29− *
30− * The primary goal of this implementation is to provide a means
31− * to partition an arbitrary block of memory without actually
32− * accessing the memory or incurring any hardware side-effects
33− * (e.g. paging). It is, in effect, a bookkeeping mechanism for
34− * buffers.
35− */
36−
37−
38−#include "memrar_allocator.h"
39−#include <linux/slab.h>
40−#include <linux/bug.h>
41−#include <linux/kernel.h>
42−
43−
44−struct memrar_allocator *memrar_create_allocator(unsigned long base,
45− size_t capacity,
46− size_t block_size)
47−{
48− struct memrar_allocator *allocator = NULL;
49− struct memrar_address_ranges *first_node = NULL;
50−
51− /*
52− * Make sure the base address is aligned on a block_size
53− * boundary.
54− *
55− * @todo Is this necessary?
56− */
57− /* base = ALIGN(base, block_size); */
58−
59− /* Validate parameters.
60− *
61− * Make sure we can allocate the entire memory space. Zero
62− * capacity or block size are obviously invalid.
63− */
64− if (base == 0
65− || capacity == 0
66− || block_size == 0
67− || ULONG_MAX - capacity < base
68− || capacity < block_size)
69− return allocator;
70−
71− /*
72− * There isn't much point in creating a memory allocator that
73− * is only capable of holding one block but we'll allow it,
74− * and issue a diagnostic.
75− */
76− WARN(capacity < block_size * 2,
77− "memrar: Only one block available to allocator.\n");
78−
79− allocator = kmalloc(sizeof(*allocator), GFP_KERNEL);
80−
81− if (allocator == NULL)
82− return allocator;
83−
84− mutex_init(&allocator->lock);
85− allocator->base = base;
86−
87− /* Round the capacity down to a multiple of block_size. */
88− allocator->capacity = (capacity / block_size) * block_size;
89−
90− allocator->block_size = block_size;
91−
92− allocator->largest_free_area = allocator->capacity;
93−
94− /* Initialize the handle and free lists. */
95− INIT_LIST_HEAD(&allocator->allocated_list.list);
96− INIT_LIST_HEAD(&allocator->free_list.list);
97−
98− first_node = kmalloc(sizeof(*first_node), GFP_KERNEL);
99− if (first_node == NULL) {
100− kfree(allocator);
101− allocator = NULL;
102− } else {
103− /* Full range of blocks is available. */
104− first_node->range.begin = base;
105− first_node->range.end = base + allocator->capacity;
106− list_add(&first_node->list,
107− &allocator->free_list.list);
108− }
109−
110− return allocator;
111−}
112−
113−void memrar_destroy_allocator(struct memrar_allocator *allocator)
114−{
115− /*
116− * Assume that the memory allocator lock isn't held at this
117− * point in time. Caller must ensure that.
118− */
119−
120− struct memrar_address_ranges *pos = NULL;
121− struct memrar_address_ranges *n = NULL;
122−
123− if (allocator == NULL)
124− return;
125−
126− mutex_lock(&allocator->lock);
127−
128− /* Reclaim free list resources. */
129− list_for_each_entry_safe(pos,
130− n,
131− &allocator->free_list.list,
132− list) {
133− list_del(&pos->list);
134− kfree(pos);
135− }
136−
137− mutex_unlock(&allocator->lock);
138−
139− kfree(allocator);
140−}
141−
142−unsigned long memrar_allocator_alloc(struct memrar_allocator *allocator,
143− size_t size)
144−{
145− struct memrar_address_ranges *pos = NULL;
146−
147− size_t num_blocks;
148− unsigned long reserved_bytes;
149−
150− /*
151− * Address of allocated buffer. We assume that zero is not a
152− * valid address.
153− */
154− unsigned long addr = 0;
155−
156− if (allocator == NULL || size == 0)
157− return addr;
158−
159− /* Reserve enough blocks to hold the amount of bytes requested. */
160− num_blocks = DIV_ROUND_UP(size, allocator->block_size);
161−
162− reserved_bytes = num_blocks * allocator->block_size;
163−
164− mutex_lock(&allocator->lock);
165−
166− if (reserved_bytes > allocator->largest_free_area) {
167− mutex_unlock(&allocator->lock);
168− return addr;
169− }
170−
171− /*
172− * Iterate through the free list to find a suitably sized
173− * range of free contiguous memory blocks.
174− *
175− * We also take the opportunity to reset the size of the
176− * largest free area size statistic.
177− */
178− list_for_each_entry(pos, &allocator->free_list.list, list) {
179− struct memrar_address_range * const fr = &pos->range;
180− size_t const curr_size = fr->end - fr->begin;
181−
182− if (curr_size >= reserved_bytes && addr == 0) {
183− struct memrar_address_range *range = NULL;
184− struct memrar_address_ranges * const new_node =
185− kmalloc(sizeof(*new_node), GFP_KERNEL);
186−
187− if (new_node == NULL)
188− break;
189−
190− list_add(&new_node->list,
191− &allocator->allocated_list.list);
192−
193− /*
194− * Carve out area of memory from end of free
195− * range.
196− */
197− range = &new_node->range;
198− range->end = fr->end;
199− fr->end -= reserved_bytes;
200− range->begin = fr->end;
201− addr = range->begin;
202−
203− /*
204− * Check if largest area has decreased in
205− * size. We'll need to continue scanning for
206− * the next largest area if it has.
207− */
208− if (curr_size == allocator->largest_free_area)
209− allocator->largest_free_area -=
210− reserved_bytes;
211− else
212− break;
213− }
214−
215− /*
216− * Reset largest free area size statistic as needed,
217− * but only if we've actually allocated memory.
218− */
219− if (addr != 0
220− && curr_size > allocator->largest_free_area) {
221− allocator->largest_free_area = curr_size;
222− break;
223− }
224− }
225−
226− mutex_unlock(&allocator->lock);
227−
228− return addr;
229−}
230−
231−long memrar_allocator_free(struct memrar_allocator *allocator,
232− unsigned long addr)
233−{
234− struct list_head *pos = NULL;
235− struct list_head *tmp = NULL;
236− struct list_head *dst = NULL;
237−
238− struct memrar_address_ranges *allocated = NULL;
239− struct memrar_address_range const *handle = NULL;
240−
241− unsigned long old_end = 0;
242− unsigned long new_chunk_size = 0;
243−
244− if (allocator == NULL)
245− return -EINVAL;
246−
247− if (addr == 0)
248− return 0; /* Ignore "free(0)". */
249−
250− mutex_lock(&allocator->lock);
251−
252− /* Find the corresponding handle. */
253− list_for_each_entry(allocated,
254− &allocator->allocated_list.list,
255− list) {
256− if (allocated->range.begin == addr) {
257− handle = &allocated->range;
258− break;
259− }
260− }
261−
262− /* No such buffer created by this allocator. */
263− if (handle == NULL) {
264− mutex_unlock(&allocator->lock);
265− return -EFAULT;
266− }
267−
268− /*
269− * Coalesce adjacent chunks of memory if possible.
270− *
271− * @note This isn't full blown coalescing since we're only
272− * coalescing at most three chunks of memory.
273− */
274− list_for_each_safe(pos, tmp, &allocator->free_list.list) {
275− /* @todo O(n) performance. Optimize. */
276−
277− struct memrar_address_range * const chunk =
278− &list_entry(pos,
279− struct memrar_address_ranges,
280− list)->range;
281−
282− /* Extend size of existing free adjacent chunk. */
283− if (chunk->end == handle->begin) {
284− /*
285− * Chunk "less than" than the one we're
286− * freeing is adjacent.
287− *
288− * Before:
289− *
290− * +-----+------+
291− * |chunk|handle|
292− * +-----+------+
293− *
294− * After:
295− *
296− * +------------+
297− * | chunk |
298− * +------------+
299− */
300−
301− struct memrar_address_ranges const * const next =
302− list_entry(pos->next,
303− struct memrar_address_ranges,
304− list);
305−
306− chunk->end = handle->end;
307−
308− /*
309− * Now check if next free chunk is adjacent to
310− * the current extended free chunk.
311− *
312− * Before:
313− *
314− * +------------+----+
315− * | chunk |next|
316− * +------------+----+
317− *
318− * After:
319− *
320− * +-----------------+
321− * | chunk |
322− * +-----------------+
323− */
324− if (!list_is_singular(pos)
325− && chunk->end == next->range.begin) {
326− chunk->end = next->range.end;
327− list_del(pos->next);
328− kfree(next);
329− }
330−
331− list_del(&allocated->list);
332−
333− new_chunk_size = chunk->end - chunk->begin;
334−
335− goto exit_memrar_free;
336−
337− } else if (handle->end == chunk->begin) {
338− /*
339− * Chunk "greater than" than the one we're
340− * freeing is adjacent.
341− *
342− * +------+-----+
343− * |handle|chunk|
344− * +------+-----+
345− *
346− * After:
347− *
348− * +------------+
349− * | chunk |
350− * +------------+
351− */
352−
353− struct memrar_address_ranges const * const prev =
354− list_entry(pos->prev,
355− struct memrar_address_ranges,
356− list);
357−
358− chunk->begin = handle->begin;
359−
360− /*
361− * Now check if previous free chunk is
362− * adjacent to the current extended free
363− * chunk.
364− *
365− *
366− * Before:
367− *
368− * +----+------------+
369− * |prev| chunk |
370− * +----+------------+
371− *
372− * After:
373− *
374− * +-----------------+
375− * | chunk |
376− * +-----------------+
377− */
378− if (!list_is_singular(pos)
379− && prev->range.end == chunk->begin) {
380− chunk->begin = prev->range.begin;
381− list_del(pos->prev);
382− kfree(prev);
383− }
384−
385− list_del(&allocated->list);
386−
387− new_chunk_size = chunk->end - chunk->begin;
388−
389− goto exit_memrar_free;
390−
391− } else if (chunk->end < handle->begin
392− && chunk->end > old_end) {
393− /* Keep track of where the entry could be
394− * potentially moved from the "allocated" list
395− * to the "free" list if coalescing doesn't
396− * occur, making sure the "free" list remains
397− * sorted.
398− */
399− old_end = chunk->end;
400− dst = pos;
401− }
402− }
403−
404− /*
405− * Nothing to coalesce.
406− *
407− * Move the entry from the "allocated" list to the "free"
408− * list.
409− */
410− list_move(&allocated->list, dst);
411− new_chunk_size = handle->end - handle->begin;
412− allocated = NULL;
413−
414−exit_memrar_free:
415−
416− if (new_chunk_size > allocator->largest_free_area)
417− allocator->largest_free_area = new_chunk_size;
418−
419− mutex_unlock(&allocator->lock);
420−
421− kfree(allocated);
422−
423− return 0;
424−}
425−
426−
427−
428−/*
429− Local Variables:
430− c-file-style: "linux"
431− End:
432−*/
drivers/staging/memrar/memrar_allocator.h+0−149
@@ -1,149 +0,0 @@
1−/*
2− * Copyright (C) 2010 Intel Corporation. All rights reserved.
3− *
4− * This program is free software; you can redistribute it and/or
5− * modify it under the terms of version 2 of the GNU General
6− * Public License as published by the Free Software Foundation.
7− *
8− * This program is distributed in the hope that it will be
9− * useful, but WITHOUT ANY WARRANTY; without even the implied
10− * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
11− * PURPOSE. See the GNU General Public License for more details.
12− * You should have received a copy of the GNU General Public
13− * License along with this program; if not, write to the Free
14− * Software Foundation, Inc., 59 Temple Place - Suite 330,
15− * Boston, MA 02111-1307, USA.
16− * The full GNU General Public License is included in this
17− * distribution in the file called COPYING.
18− */
19−
20−#ifndef MEMRAR_ALLOCATOR_H
21−#define MEMRAR_ALLOCATOR_H
22−
23−
24−#include <linux/mutex.h>
25−#include <linux/list.h>
26−#include <linux/types.h>
27−#include <linux/kernel.h>
28−
29−
30−/**
31− * struct memrar_address_range - struct that describes a memory range
32− * @begin: Beginning of available address range.
33− * @end: End of available address range, one past the end,
34− * i.e. [begin, end).
35− */
36−struct memrar_address_range {
37−/* private: internal use only */
38− unsigned long begin;
39− unsigned long end;
40−};
41−
42−/**
43− * struct memrar_address_ranges - list of areas of memory.
44− * @list: Linked list of address ranges.
45− * @range: Memory address range corresponding to given list node.
46− */
47−struct memrar_address_ranges {
48−/* private: internal use only */
49− struct list_head list;
50− struct memrar_address_range range;
51−};
52−
53−/**
54− * struct memrar_allocator - encapsulation of the memory allocator state
55− * @lock: Lock used to synchronize access to the memory
56− * allocator state.
57− * @base: Base (start) address of the allocator memory
58− * space.
59− * @capacity: Size of the allocator memory space in bytes.
60− * @block_size: The size in bytes of individual blocks within
61− * the allocator memory space.
62− * @largest_free_area: Largest free area of memory in the allocator
63− * in bytes.
64− * @allocated_list: List of allocated memory block address
65− * ranges.
66− * @free_list: List of free address ranges.
67− *
68− * This structure contains all memory allocator state, including the
69− * base address, capacity, free list, lock, etc.
70− */
71−struct memrar_allocator {
72−/* private: internal use only */
73− struct mutex lock;
74− unsigned long base;
75− size_t capacity;
76− size_t block_size;
77− size_t largest_free_area;
78− struct memrar_address_ranges allocated_list;
79− struct memrar_address_ranges free_list;
80−};
81−
82−/**
83− * memrar_create_allocator() - create a memory allocator
84− * @base: Address at which the memory allocator begins.
85− * @capacity: Desired size of the memory allocator. This value must
86− * be larger than the block_size, ideally more than twice
87− * as large since there wouldn't be much point in using a
88− * memory allocator otherwise.
89− * @block_size: The size of individual blocks within the memory
90− * allocator. This value must smaller than the
91− * capacity.
92− *
93− * Create a memory allocator with the given capacity and block size.
94− * The capacity will be reduced to be a multiple of the block size, if
95− * necessary.
96− *
97− * Returns an instance of the memory allocator, if creation succeeds,
98− * otherwise zero if creation fails. Failure may occur if not enough
99− * kernel memory exists to create the memrar_allocator instance
100− * itself, or if the capacity and block_size arguments are not
101− * compatible or make sense.
102− */
103−struct memrar_allocator *memrar_create_allocator(unsigned long base,
104− size_t capacity,
105− size_t block_size);
106−
107−/**
108− * memrar_destroy_allocator() - destroy allocator
109− * @allocator: The allocator being destroyed.
110− *
111− * Reclaim resources held by the memory allocator. The caller must
112− * explicitly free all memory reserved by memrar_allocator_alloc()
113− * prior to calling this function. Otherwise leaks will occur.
114− */
115−void memrar_destroy_allocator(struct memrar_allocator *allocator);
116−
117−/**
118− * memrar_allocator_alloc() - reserve an area of memory of given size
119− * @allocator: The allocator instance being used to reserve buffer.
120− * @size: The size in bytes of the buffer to allocate.
121− *
122− * This functions reserves an area of memory managed by the given
123− * allocator. It returns zero if allocation was not possible.
124− * Failure may occur if the allocator no longer has space available.
125− */
126−unsigned long memrar_allocator_alloc(struct memrar_allocator *allocator,
127− size_t size);
128−
129−/**
130− * memrar_allocator_free() - release buffer starting at given address
131− * @allocator: The allocator instance being used to release the buffer.
132− * @address: The address of the buffer being released.
133− *
134− * Release an area of memory starting at the given address. Failure
135− * could occur if the given address is not in the address space
136− * managed by the allocator. Returns zero on success or an errno
137− * (negative value) on failure.
138− */
139−long memrar_allocator_free(struct memrar_allocator *allocator,
140− unsigned long address);
141−
142−#endif /* MEMRAR_ALLOCATOR_H */
143−
144−
145−/*
146− Local Variables:
147− c-file-style: "linux"
148− End:
149−*/
drivers/staging/memrar/memrar_handler.c+0−1007
@@ -1,1007 +0,0 @@
1−/*
2− * memrar_handler 1.0: An Intel restricted access region handler device
3− *
4− * Copyright (C) 2010 Intel Corporation. All rights reserved.
5− *
6− * This program is free software; you can redistribute it and/or
7− * modify it under the terms of version 2 of the GNU General
8− * Public License as published by the Free Software Foundation.
9− *
10− * This program is distributed in the hope that it will be
11− * useful, but WITHOUT ANY WARRANTY; without even the implied
12− * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
13− * PURPOSE. See the GNU General Public License for more details.
14− * You should have received a copy of the GNU General Public
15− * License along with this program; if not, write to the Free
16− * Software Foundation, Inc., 59 Temple Place - Suite 330,
17− * Boston, MA 02111-1307, USA.
18− * The full GNU General Public License is included in this
19− * distribution in the file called COPYING.
20− *
21− * -------------------------------------------------------------------
22− *
23− * Moorestown restricted access regions (RAR) provide isolated
24− * areas of main memory that are only acceessible by authorized
25− * devices.
26− *
27− * The Intel Moorestown RAR handler module exposes a kernel space
28− * RAR memory management mechanism. It is essentially a
29− * RAR-specific allocator.
30− *
31− * Besides providing RAR buffer management, the RAR handler also
32− * behaves in many ways like an OS virtual memory manager. For
33− * example, the RAR "handles" created by the RAR handler are
34− * analogous to user space virtual addresses.
35− *
36− * RAR memory itself is never accessed directly by the RAR
37− * handler.
38− */
39−
40−#include <linux/miscdevice.h>
41−#include <linux/fs.h>
42−#include <linux/slab.h>
43−#include <linux/kref.h>
44−#include <linux/mutex.h>
45−#include <linux/kernel.h>
46−#include <linux/uaccess.h>
47−#include <linux/mm.h>
48−#include <linux/ioport.h>
49−#include <linux/io.h>
50−#include <linux/rar_register.h>
51−
52−#include "memrar.h"
53−#include "memrar_allocator.h"
54−
55−
56−#define MEMRAR_VER "1.0"
57−
58−/*
59− * Moorestown supports three restricted access regions.
60− *
61− * We only care about the first two, video and audio. The third,
62− * reserved for Chaabi and the P-unit, will be handled by their
63− * respective drivers.
64− */
65−#define MRST_NUM_RAR 2
66−
67−/* ---------------- -------------------- ------------------- */
68−
69−/**
70− * struct memrar_buffer_info - struct that keeps track of all RAR buffers
71− * @list: Linked list of memrar_buffer_info objects.
72− * @buffer: Core RAR buffer information.
73− * @refcount: Reference count.
74− * @owner: File handle corresponding to process that reserved the
75− * block of memory in RAR. This will be zero for buffers
76− * allocated by other drivers instead of by a user space
77− * process.
78− *
79− * This structure encapsulates a link list of RAR buffers, as well as
80− * other characteristics specific to a given list node, such as the
81− * reference count on the corresponding RAR buffer.
82− */
83−struct memrar_buffer_info {
84− struct list_head list;
85− struct RAR_buffer buffer;
86− struct kref refcount;
87− struct file *owner;
88−};
89−
90−/**
91− * struct memrar_rar_info - characteristics of a given RAR
92− * @base: Base bus address of the RAR.
93− * @length: Length of the RAR.
94− * @iobase: Virtual address of RAR mapped into kernel.
95− * @allocator: Allocator associated with the RAR. Note the allocator
96− * "capacity" may be smaller than the RAR length if the
97− * length is not a multiple of the configured allocator
98− * block size.
99− * @buffers: Table that keeps track of all reserved RAR buffers.
100− * @lock: Lock used to synchronize access to RAR-specific data
101− * structures.
102− *
103− * Each RAR has an associated memrar_rar_info structure that describes
104− * where in memory the RAR is located, how large it is, and a list of
105− * reserved RAR buffers inside that RAR. Each RAR also has a mutex
106− * associated with it to reduce lock contention when operations on
107− * multiple RARs are performed in parallel.
108− */
109−struct memrar_rar_info {
110− dma_addr_t base;
111− unsigned long length;
112− void __iomem *iobase;
113− struct memrar_allocator *allocator;
114− struct memrar_buffer_info buffers;
115− struct mutex lock;
116− int allocated; /* True if we own this RAR */
117−};
118−
119−/*
120− * Array of RAR characteristics.
121− */
122−static struct memrar_rar_info memrars[MRST_NUM_RAR];
123−
124−/* ---------------- -------------------- ------------------- */
125−
126−/* Validate RAR type. */
127−static inline int memrar_is_valid_rar_type(u32 type)
128−{
129− return type == RAR_TYPE_VIDEO || type == RAR_TYPE_AUDIO;
130−}
131−
132−/* Check if an address/handle falls with the given RAR memory range. */
133−static inline int memrar_handle_in_range(struct memrar_rar_info *rar,
134− u32 vaddr)
135−{
136− unsigned long const iobase = (unsigned long) (rar->iobase);
137− return (vaddr >= iobase && vaddr < iobase + rar->length);
138−}
139−
140−/* Retrieve RAR information associated with the given handle. */
141−static struct memrar_rar_info *memrar_get_rar_info(u32 vaddr)
142−{
143− int i;
144− for (i = 0; i < MRST_NUM_RAR; ++i) {
145− struct memrar_rar_info * const rar = &memrars[i];
146− if (memrar_handle_in_range(rar, vaddr))
147− return rar;
148− }
149−
150− return NULL;
151−}
152−
153−/**
154− * memrar_get_bus address - handle to bus address
155− *
156− * Retrieve bus address from given handle.
157− *
158− * Returns address corresponding to given handle. Zero if handle is
159− * invalid.
160− */
161−static dma_addr_t memrar_get_bus_address(
162− struct memrar_rar_info *rar,
163− u32 vaddr)
164−{
165− unsigned long const iobase = (unsigned long) (rar->iobase);
166−
167− if (!memrar_handle_in_range(rar, vaddr))
168− return 0;
169−
170− /*
171− * An assumption is made that the virtual address offset is
172− * the same as the bus address offset, at least based on the
173− * way this driver is implemented. For example, vaddr + 2 ==
174− * baddr + 2.
175− *
176− * @todo Is that a valid assumption?
177− */
178− return rar->base + (vaddr - iobase);
179−}
180−
181−/**
182− * memrar_get_physical_address - handle to physical address
183− *
184− * Retrieve physical address from given handle.
185− *
186− * Returns address corresponding to given handle. Zero if handle is
187− * invalid.
188− */
189−static dma_addr_t memrar_get_physical_address(
190− struct memrar_rar_info *rar,
191− u32 vaddr)
192−{
193− /*
194− * @todo This assumes that the bus address and physical
195− * address are the same. That is true for Moorestown
196− * but not necessarily on other platforms. This
197− * deficiency should be addressed at some point.
198− */
199− return memrar_get_bus_address(rar, vaddr);
200−}
201−
202−/**
203− * memrar_release_block - release a block to the pool
204− * @kref: kref of block
205− *
206− * Core block release code. A node has hit zero references so can
207− * be released and the lists must be updated.
208− *
209− * Note: This code removes the node from a list. Make sure any list
210− * iteration is performed using list_for_each_safe().
211− */
212−static void memrar_release_block_i(struct kref *ref)
213−{
214− /*
215− * Last reference is being released. Remove from the table,
216− * and reclaim resources.
217− */
218−
219− struct memrar_buffer_info * const node =
220− container_of(ref, struct memrar_buffer_info, refcount);
221−
222− struct RAR_block_info * const user_info =
223− &node->buffer.info;
224−
225− struct memrar_allocator * const allocator =
226− memrars[user_info->type].allocator;
227−
228− list_del(&node->list);
229−
230− memrar_allocator_free(allocator, user_info->handle);
231−
232− kfree(node);
233−}
234−
235−/**
236− * memrar_init_rar_resources - configure a RAR
237− * @rarnum: rar that has been allocated
238− * @devname: name of our device
239− *
240− * Initialize RAR parameters, such as bus addresses, etc and make
241− * the resource accessible.
242− */
243−static int memrar_init_rar_resources(int rarnum, char const *devname)
244−{
245− /* ---- Sanity Checks ----
246− * 1. RAR bus addresses in both Lincroft and Langwell RAR
247− * registers should be the same.
248− * a. There's no way we can do this through IA.
249− *
250− * 2. Secure device ID in Langwell RAR registers should be set
251− * appropriately, e.g. only LPE DMA for the audio RAR, and
252− * security for the other Langwell based RAR registers.
253− * a. There's no way we can do this through IA.
254− *
255− * 3. Audio and video RAR registers and RAR access should be
256− * locked down. If not, enable RAR access control. Except
257− * for debugging purposes, there is no reason for them to
258− * be unlocked.
259− * a. We can only do this for the Lincroft (IA) side.
260− *
261− * @todo Should the RAR handler driver even be aware of audio
262− * and video RAR settings?
263− */
264−
265− /*
266− * RAR buffer block size.
267− *
268− * We choose it to be the size of a page to simplify the
269− * /dev/memrar mmap() implementation and usage. Otherwise
270− * paging is not involved once an RAR is locked down.
271− */
272− static size_t const RAR_BLOCK_SIZE = PAGE_SIZE;
273−
274− dma_addr_t low, high;
275− struct memrar_rar_info * const rar = &memrars[rarnum];
276−
277− BUG_ON(MRST_NUM_RAR != ARRAY_SIZE(memrars));
278− BUG_ON(!memrar_is_valid_rar_type(rarnum));
279− BUG_ON(rar->allocated);
280−
281− if (rar_get_address(rarnum, &low, &high) != 0)
282− /* No RAR is available. */
283− return -ENODEV;
284−
285− if (low == 0 || high == 0) {
286− rar->base = 0;
287− rar->length = 0;
288− rar->iobase = NULL;
289− rar->allocator = NULL;
290− return -ENOSPC;
291− }
292−
293− /*
294− * @todo Verify that LNC and LNW RAR register contents
295− * addresses, security, etc are compatible and
296− * consistent).
297− */
298−
299− rar->length = high - low + 1;
300−
301− /* Claim RAR memory as our own. */
302− if (request_mem_region(low, rar->length, devname) == NULL) {
303− rar->length = 0;
304− pr_err("%s: Unable to claim RAR[%d] memory.\n",
305− devname, rarnum);
306− pr_err("%s: RAR[%d] disabled.\n", devname, rarnum);
307− return -EBUSY;
308− }
309−
310− rar->base = low;
311−
312− /*
313− * Now map it into the kernel address space.
314− *
315− * Note that the RAR memory may only be accessed by IA
316− * when debugging. Otherwise attempts to access the
317− * RAR memory when it is locked down will result in
318− * behavior similar to writing to /dev/null and
319− * reading from /dev/zero. This behavior is enforced
320− * by the hardware. Even if we don't access the
321− * memory, mapping it into the kernel provides us with
322− * a convenient RAR handle to bus address mapping.
323− */
324− rar->iobase = ioremap_nocache(rar->base, rar->length);
325− if (rar->iobase == NULL) {
326− pr_err("%s: Unable to map RAR memory.\n", devname);
327− release_mem_region(low, rar->length);
328− return -ENOMEM;
329− }
330−
331− /* Initialize corresponding memory allocator. */
332− rar->allocator = memrar_create_allocator((unsigned long) rar->iobase,
333− rar->length, RAR_BLOCK_SIZE);
334− if (rar->allocator == NULL) {
335− iounmap(rar->iobase);
336− release_mem_region(low, rar->length);
337− return -ENOMEM;
338− }
339−
340− pr_info("%s: BRAR[%d] bus address range = [0x%lx, 0x%lx]\n",
341− devname, rarnum, (unsigned long) low, (unsigned long) high);
342−
343− pr_info("%s: BRAR[%d] size = %zu KiB\n",
344− devname, rarnum, rar->allocator->capacity / 1024);
345−
346− rar->allocated = 1;
347− return 0;
348−}
349−
350−/**
351− * memrar_fini_rar_resources - free up RAR resources
352− *
353− * Finalize RAR resources. Free up the resource tables, hand the memory
354− * back to the kernel, unmap the device and release the address space.
355− */
356−static void memrar_fini_rar_resources(void)
357−{
358− int z;
359− struct memrar_buffer_info *pos;
360− struct memrar_buffer_info *tmp;
361−
362− /*
363− * @todo Do we need to hold a lock at this point in time?
364− * (module initialization failure or exit?)
365− */
366−
367− for (z = MRST_NUM_RAR; z-- != 0; ) {
368− struct memrar_rar_info * const rar = &memrars[z];
369−
370− if (!rar->allocated)
371− continue;
372−
373− /* Clean up remaining resources. */
374−
375− list_for_each_entry_safe(pos,
376− tmp,
377− &rar->buffers.list,
378− list) {
379− kref_put(&pos->refcount, memrar_release_block_i);
380− }
381−
382− memrar_destroy_allocator(rar->allocator);
383− rar->allocator = NULL;
384−
385− iounmap(rar->iobase);
386− release_mem_region(rar->base, rar->length);
387−
388− rar->iobase = NULL;
389− rar->base = 0;
390− rar->length = 0;
391−
392− unregister_rar(z);
393− }
394−}
395−
396−/**
397− * memrar_reserve_block - handle an allocation request
398− * @request: block being requested
399− * @filp: owner it is tied to
400− *
401− * Allocate a block of the requested RAR. If successful return the
402− * request object filled in and zero, if not report an error code
403− */
404−
405−static long memrar_reserve_block(struct RAR_buffer *request,
406− struct file *filp)
407−{
408− struct RAR_block_info * const rinfo = &request->info;
409− struct RAR_buffer *buffer;
410− struct memrar_buffer_info *buffer_info;
411− u32 handle;
412− struct memrar_rar_info *rar = NULL;
413−
414− /* Prevent array overflow. */
415− if (!memrar_is_valid_rar_type(rinfo->type))
416− return -EINVAL;
417−
418− rar = &memrars[rinfo->type];
419− if (!rar->allocated)
420− return -ENODEV;
421−
422− /* Reserve memory in RAR. */
423− handle = memrar_allocator_alloc(rar->allocator, rinfo->size);
424− if (handle == 0)
425− return -ENOMEM;
426−
427− buffer_info = kmalloc(sizeof(*buffer_info), GFP_KERNEL);
428−
429− if (buffer_info == NULL) {
430− memrar_allocator_free(rar->allocator, handle);
431− return -ENOMEM;
432− }
433−
434− buffer = &buffer_info->buffer;
435− buffer->info.type = rinfo->type;
436− buffer->info.size = rinfo->size;
437−
438− /* Memory handle corresponding to the bus address. */
439− buffer->info.handle = handle;
440− buffer->bus_address = memrar_get_bus_address(rar, handle);
441−
442− /*
443− * Keep track of owner so that we can later cleanup if
444− * necessary.
445− */
446− buffer_info->owner = filp;
447−
448− kref_init(&buffer_info->refcount);
449−
450− mutex_lock(&rar->lock);
451− list_add(&buffer_info->list, &rar->buffers.list);
452− mutex_unlock(&rar->lock);
453−
454− rinfo->handle = buffer->info.handle;
455− request->bus_address = buffer->bus_address;
456−
457− return 0;
458−}
459−
460−/**
461− * memrar_release_block - release a RAR block
462− * @addr: address in RAR space
463− *
464− * Release a previously allocated block. Releases act on complete
465− * blocks, partially freeing a block is not supported
466− */
467−
468−static long memrar_release_block(u32 addr)
469−{
470− struct memrar_buffer_info *pos;
471− struct memrar_buffer_info *tmp;
472− struct memrar_rar_info * const rar = memrar_get_rar_info(addr);
473− long result = -EINVAL;
474−
475− if (rar == NULL)
476− return -ENOENT;
477−
478− mutex_lock(&rar->lock);
479−
480− /*
481− * Iterate through the buffer list to find the corresponding
482− * buffer to be released.
483− */
484− list_for_each_entry_safe(pos,
485− tmp,
486− &rar->buffers.list,
487− list) {
488− struct RAR_block_info * const info =
489− &pos->buffer.info;
490−
491− /*
492− * Take into account handle offsets that may have been
493− * added to the base handle, such as in the following
494− * scenario:
495− *
496− * u32 handle = base + offset;
497− * rar_handle_to_bus(handle);
498− * rar_release(handle);
499− */
500− if (addr >= info->handle
501− && addr < (info->handle + info->size)
502− && memrar_is_valid_rar_type(info->type)) {
503− kref_put(&pos->refcount, memrar_release_block_i);
504− result = 0;
505− break;
506− }
507− }
508−
509− mutex_unlock(&rar->lock);
510−
511− return result;
512−}
513−
514−/**
515− * memrar_get_stats - read statistics for a RAR
516− * @r: statistics to be filled in
517− *
518− * Returns the statistics data for the RAR, or an error code if
519− * the request cannot be completed
520− */
521−static long memrar_get_stat(struct RAR_stat *r)
522−{
523− struct memrar_allocator *allocator;
524−
525− if (!memrar_is_valid_rar_type(r->type))
526− return -EINVAL;
527−
528− if (!memrars[r->type].allocated)
529− return -ENODEV;
530−
531− allocator = memrars[r->type].allocator;
532−
533− BUG_ON(allocator == NULL);
534−
535− /*
536− * Allocator capacity doesn't change over time. No
537− * need to synchronize.
538− */
539− r->capacity = allocator->capacity;
540−
541− mutex_lock(&allocator->lock);
542− r->largest_block_size = allocator->largest_free_area;
543− mutex_unlock(&allocator->lock);
544− return 0;
545−}
546−
547−/**
548− * memrar_ioctl - ioctl callback
549− * @filp: file issuing the request
550− * @cmd: command
551− * @arg: pointer to control information
552− *
553− * Perform one of the ioctls supported by the memrar device
554− */
555−
556−static long memrar_ioctl(struct file *filp,
557− unsigned int cmd,
558− unsigned long arg)
559−{
560− void __user *argp = (void __user *)arg;
561− long result = 0;
562−
563− struct RAR_buffer buffer;
564− struct RAR_block_info * const request = &buffer.info;
565− struct RAR_stat rar_info;
566− u32 rar_handle;
567−
568− switch (cmd) {
569− case RAR_HANDLER_RESERVE:
570− if (copy_from_user(request,
571− argp,
572− sizeof(*request)))
573− return -EFAULT;
574−
575− result = memrar_reserve_block(&buffer, filp);
576− if (result != 0)
577− return result;
578−
579− return copy_to_user(argp, request, sizeof(*request));
580−
581− case RAR_HANDLER_RELEASE:
582− if (copy_from_user(&rar_handle,
583− argp,
584− sizeof(rar_handle)))
585− return -EFAULT;
586−
587− return memrar_release_block(rar_handle);
588−
589− case RAR_HANDLER_STAT:
590− if (copy_from_user(&rar_info,
591− argp,
592− sizeof(rar_info)))
593− return -EFAULT;
594−
595− /*
596− * Populate the RAR_stat structure based on the RAR
597− * type given by the user
598− */
599− if (memrar_get_stat(&rar_info) != 0)
600− return -EINVAL;
601−
602− /*
603− * @todo Do we need to verify destination pointer
604− * "argp" is non-zero? Is that already done by
605− * copy_to_user()?
606− */
607− return copy_to_user(argp,
608− &rar_info,
609− sizeof(rar_info)) ? -EFAULT : 0;
610−
611− default:
612− return -ENOTTY;
613− }
614−
615− return 0;
616−}
617−
618−/**
619− * memrar_mmap - mmap helper for deubgging
620− * @filp: handle doing the mapping
621− * @vma: memory area
622− *
623− * Support the mmap operation on the RAR space for debugging systems
624− * when the memory is not locked down.
625− */
626−
627−static int memrar_mmap(struct file *filp, struct vm_area_struct *vma)
628−{
629− /*
630− * This mmap() implementation is predominantly useful for
631− * debugging since the CPU will be prevented from accessing
632− * RAR memory by the hardware when RAR is properly locked
633− * down.
634− *
635− * In order for this implementation to be useful RAR memory
636− * must be not be locked down. However, we only want to do
637− * that when debugging. DO NOT leave RAR memory unlocked in a
638− * deployed device that utilizes RAR.
639− */
640−
641− size_t const size = vma->vm_end - vma->vm_start;
642−
643− /* Users pass the RAR handle as the mmap() offset parameter. */
644− unsigned long const handle = vma->vm_pgoff << PAGE_SHIFT;
645−
646− struct memrar_rar_info * const rar = memrar_get_rar_info(handle);
647− unsigned long pfn;
648−
649− /* Only allow priviledged apps to go poking around this way */
650− if (!capable(CAP_SYS_RAWIO))
651− return -EPERM;
652−
653− /* Invalid RAR handle or size passed to mmap(). */
654− if (rar == NULL
655− || handle == 0
656− || size > (handle - (unsigned long) rar->iobase))
657− return -EINVAL;
658−
659− /*
660− * Retrieve physical address corresponding to the RAR handle,
661− * and convert it to a page frame.
662− */
663− pfn = memrar_get_physical_address(rar, handle) >> PAGE_SHIFT;
664−
665−
666− pr_debug("memrar: mapping RAR range [0x%lx, 0x%lx) into user space.\n",
667− handle,
668− handle + size);
669−
670− /*
671− * Map RAR memory into user space. This is really only useful
672− * for debugging purposes since the memory won't be
673− * accessible, i.e. reads return zero and writes are ignored,
674− * when RAR access control is enabled.
675− */
676− if (remap_pfn_range(vma,
677− vma->vm_start,
678− pfn,
679− size,
680− vma->vm_page_prot))
681− return -EAGAIN;
682−
683− /* vma->vm_ops = &memrar_mem_ops; */
684−
685− return 0;
686−}
687−
688−/**
689− * memrar_open - device open method
690− * @inode: inode to open
691− * @filp: file handle
692− *
693− * As we support multiple arbitrary opens there is no work to be done
694− * really.
695− */
696−
697−static int memrar_open(struct inode *inode, struct file *filp)
698−{
699− nonseekable_open(inode, filp);
700− return 0;
701−}
702−
703−/**
704− * memrar_release - close method for miscev
705− * @inode: inode of device
706− * @filp: handle that is going away
707− *
708− * Free up all the regions that belong to this file handle. We use
709− * the handle as a natural Linux style 'lifetime' indicator and to
710− * ensure resources are not leaked when their owner explodes in an
711− * unplanned fashion.
712− */
713−
714−static int memrar_release(struct inode *inode, struct file *filp)
715−{
716− /* Free all regions associated with the given file handle. */
717−
718− struct memrar_buffer_info *pos;
719− struct memrar_buffer_info *tmp;
720− int z;
721−
722− for (z = 0; z != MRST_NUM_RAR; ++z) {
723− struct memrar_rar_info * const rar = &memrars[z];
724−
725− mutex_lock(&rar->lock);
726−
727− list_for_each_entry_safe(pos,
728− tmp,
729− &rar->buffers.list,
730− list) {
731− if (filp == pos->owner)
732− kref_put(&pos->refcount,
733− memrar_release_block_i);
734− }
735−
736− mutex_unlock(&rar->lock);
737− }
738−
739− return 0;
740−}
741−
742−/**
743− * rar_reserve - reserve RAR memory
744− * @buffers: buffers to reserve
745− * @count: number wanted
746− *
747− * Reserve a series of buffers in the RAR space. Returns the number of
748− * buffers successfully allocated
749− */
750−
751−size_t rar_reserve(struct RAR_buffer *buffers, size_t count)
752−{
753− struct RAR_buffer * const end =
754− (buffers == NULL ? buffers : buffers + count);
755− struct RAR_buffer *i;
756−
757− size_t reserve_count = 0;
758−
759− for (i = buffers; i != end; ++i) {
760− if (memrar_reserve_block(i, NULL) == 0)
761− ++reserve_count;
762− else
763− i->bus_address = 0;
764− }
765−
766− return reserve_count;
767−}
768−EXPORT_SYMBOL(rar_reserve);
769−
770−/**
771− * rar_release - return RAR buffers
772− * @buffers: buffers to release
773− * @size: size of released block
774− *
775− * Return a set of buffers to the RAR pool
776− */
777−
778−size_t rar_release(struct RAR_buffer *buffers, size_t count)
779−{
780− struct RAR_buffer * const end =
781− (buffers == NULL ? buffers : buffers + count);
782− struct RAR_buffer *i;
783−
784− size_t release_count = 0;
785−
786− for (i = buffers; i != end; ++i) {
787− u32 * const handle = &i->info.handle;
788− if (memrar_release_block(*handle) == 0) {
789− /*
790− * @todo We assume we should do this each time
791− * the ref count is decremented. Should
792− * we instead only do this when the ref
793− * count has dropped to zero, and the
794− * buffer has been completely
795− * released/unmapped?
796− */
797− *handle = 0;
798− ++release_count;
799− }
800− }
801−
802− return release_count;
803−}
804−EXPORT_SYMBOL(rar_release);
805−
806−/**
807− * rar_handle_to_bus - RAR to bus address
808− * @buffers: RAR buffer structure
809− * @count: number of buffers to convert
810− *
811− * Turn a list of RAR handle mappings into actual bus addresses. Note
812− * that when the device is locked down the bus addresses in question
813− * are not CPU accessible.
814− */
815−
816−size_t rar_handle_to_bus(struct RAR_buffer *buffers, size_t count)
817−{
818− struct RAR_buffer * const end =
819− (buffers == NULL ? buffers : buffers + count);
820− struct RAR_buffer *i;
821− struct memrar_buffer_info *pos;
822−
823− size_t conversion_count = 0;
824−
825− /*
826− * Find all bus addresses corresponding to the given handles.
827− *
828− * @todo Not liking this nested loop. Optimize.
829− */
830− for (i = buffers; i != end; ++i) {
831− struct memrar_rar_info * const rar =
832− memrar_get_rar_info(i->info.handle);
833−
834− /*
835− * Check if we have a bogus handle, and then continue
836− * with remaining buffers.
837− */
838− if (rar == NULL) {
839− i->bus_address = 0;
840− continue;
841− }
842−
843− mutex_lock(&rar->lock);
844−
845− list_for_each_entry(pos, &rar->buffers.list, list) {
846− struct RAR_block_info * const user_info =
847− &pos->buffer.info;
848−
849− /*
850− * Take into account handle offsets that may
851− * have been added to the base handle, such as
852− * in the following scenario:
853− *
854− * u32 handle = base + offset;
855− * rar_handle_to_bus(handle);
856− */
857−
858− if (i->info.handle >= user_info->handle
859− && i->info.handle < (user_info->handle
860− + user_info->size)) {
861− u32 const offset =
862− i->info.handle - user_info->handle;
863−
864− i->info.type = user_info->type;
865− i->info.size = user_info->size - offset;
866− i->bus_address =
867− pos->buffer.bus_address
868− + offset;
869−
870− /* Increment the reference count. */
871− kref_get(&pos->refcount);
872−
873− ++conversion_count;
874− break;
875− } else {
876− i->bus_address = 0;
877− }
878− }
879−
880− mutex_unlock(&rar->lock);
881− }
882−
883− return conversion_count;
884−}
885−EXPORT_SYMBOL(rar_handle_to_bus);
886−
887−static const struct file_operations memrar_fops = {
888− .owner = THIS_MODULE,
889− .unlocked_ioctl = memrar_ioctl,
890− .mmap = memrar_mmap,
891− .open = memrar_open,
892− .release = memrar_release,
893− .llseek = no_llseek,
894−};
895−
896−static struct miscdevice memrar_miscdev = {
897− .minor = MISC_DYNAMIC_MINOR, /* dynamic allocation */
898− .name = "memrar", /* /dev/memrar */
899− .fops = &memrar_fops
900−};
901−
902−static char const banner[] __initdata =
903− KERN_INFO
904− "Intel RAR Handler: " MEMRAR_VER " initialized.\n";
905−
906−/**
907− * memrar_registration_callback - RAR obtained
908− * @rar: RAR number
909− *
910− * We have been granted ownership of the RAR. Add it to our memory
911− * management tables
912− */
913−
914−static int memrar_registration_callback(unsigned long rar)
915−{
916− /*
917− * We initialize the RAR parameters early on so that we can
918− * discontinue memrar device initialization and registration
919− * if suitably configured RARs are not available.
920− */
921− return memrar_init_rar_resources(rar, memrar_miscdev.name);
922−}
923−
924−/**
925− * memrar_init - initialise RAR support
926− *
927− * Initialise support for RAR handlers. This may get loaded before
928− * the RAR support is activated, but the callbacks on the registration
929− * will handle that situation for us anyway.
930− */
931−
932−static int __init memrar_init(void)
933−{
934− int err;
935− int i;
936−
937− printk(banner);
938−
939− /*
940− * Some delayed initialization is performed in this driver.
941− * Make sure resources that are used during driver clean-up
942− * (e.g. during driver's release() function) are fully
943− * initialized before first use. This is particularly
944− * important for the case when the delayed initialization
945− * isn't completed, leaving behind a partially initialized
946− * driver.
947− *
948− * Such a scenario can occur when RAR is not available on the
949− * platform, and the driver is release()d.
950− */
951− for (i = 0; i != ARRAY_SIZE(memrars); ++i) {
952− struct memrar_rar_info * const rar = &memrars[i];
953− mutex_init(&rar->lock);
954− INIT_LIST_HEAD(&rar->buffers.list);
955− }
956−
957− err = misc_register(&memrar_miscdev);
958− if (err)
959− return err;
960−
961− /* Now claim the two RARs we want */
962− err = register_rar(0, memrar_registration_callback, 0);
963− if (err)
964− goto fail;
965−
966− err = register_rar(1, memrar_registration_callback, 1);
967− if (err == 0)
968− return 0;
969−
970− /* It is possible rar 0 registered and allocated resources then rar 1
971− failed so do a full resource free */
972− memrar_fini_rar_resources();
973−fail:
974− misc_deregister(&memrar_miscdev);
975− return err;
976−}
977−
978−/**
979− * memrar_exit - unregister and unload
980− *
981− * Unregister the device and then unload any mappings and release
982− * the RAR resources
983− */
984−
985−static void __exit memrar_exit(void)
986−{
987− misc_deregister(&memrar_miscdev);
988− memrar_fini_rar_resources();
989−}
990−
991−
992−module_init(memrar_init);
993−module_exit(memrar_exit);
994−
995−
996−MODULE_AUTHOR("Ossama Othman <ossama.othman@intel.com>");
997−MODULE_DESCRIPTION("Intel Restricted Access Region Handler");
998−MODULE_LICENSE("GPL");
999−MODULE_VERSION(MEMRAR_VER);
1000−
1001−
1002−
1003−/*
1004− Local Variables:
1005− c-file-style: "linux"
1006− End:
1007−*/
drivers/staging/olpc_dcon/Kconfig+1−1
@@ -9,7 +9,7 @@ config FB_OLPC_DCON · 8 unmodified lines
99
1010 config FB_OLPC_DCON_1
1111 bool "OLPC XO-1 DCON support"
12− depends on FB_OLPC_DCON
12+ depends on FB_OLPC_DCON && GPIO_CS5535
1313 default y
1414 ---help---
1515 Enable support for the DCON in XO-1 model laptops. The kernel
drivers/staging/olpc_dcon/olpc_dcon_xo_1_5.c+1−0
@@ -7,6 +7,7 @@ · 6 unmodified lines
77 */
88
99 #include <linux/acpi.h>
10+#include <linux/delay.h>
1011 #include <linux/pci.h>
1112 #include <linux/gpio.h>
1213 #include <asm/olpc.h>
drivers/staging/rtl8187se/Kconfig+1−0
@@ -1,6 +1,7 @@
11 config R8187SE
22 tristate "RealTek RTL8187SE Wireless LAN NIC driver"
33 depends on PCI && WLAN
4+ depends on m
45 select WIRELESS_EXT
56 select WEXT_PRIV
67 select EEPROM_93CX6
drivers/staging/rtl8192e/Kconfig+1−0
@@ -1,6 +1,7 @@
11 config RTL8192E
22 tristate "RealTek RTL8192E Wireless LAN NIC driver"
33 depends on PCI && WLAN
4+ depends on m
45 select WIRELESS_EXT
56 select WEXT_PRIV
67 select CRYPTO
drivers/staging/rtl8192u/Kconfig+1−0
@@ -1,6 +1,7 @@
11 config RTL8192U
22 tristate "RealTek RTL8192U Wireless LAN NIC driver"
33 depends on PCI && WLAN && USB
4+ depends on m
45 select WIRELESS_EXT
56 select WEXT_PRIV
67 select CRYPTO
drivers/staging/rts_pstor/rtsx.c+7−7
@@ -824,13 +824,13 @@ static void rtsx_init_options(struct rtsx_chip *chip) · 823 unmodified lines
824824 chip->fpga_ms_hg_clk = CLK_80;
825825 chip->fpga_ms_4bit_clk = CLK_80;
826826 chip->fpga_ms_1bit_clk = CLK_40;
827− chip->asic_sd_sdr104_clk = 207;
828− chip->asic_sd_sdr50_clk = 99;
829− chip->asic_sd_ddr50_clk = 99;
830− chip->asic_sd_hs_clk = 99;
831− chip->asic_mmc_52m_clk = 99;
832− chip->asic_ms_hg_clk = 119;
833− chip->asic_ms_4bit_clk = 79;
827+ chip->asic_sd_sdr104_clk = 203;
828+ chip->asic_sd_sdr50_clk = 98;
829+ chip->asic_sd_ddr50_clk = 98;
830+ chip->asic_sd_hs_clk = 98;
831+ chip->asic_mmc_52m_clk = 98;
832+ chip->asic_ms_hg_clk = 117;
833+ chip->asic_ms_4bit_clk = 78;
834834 chip->asic_ms_1bit_clk = 39;
835835 chip->ssc_depth_sd_sdr104 = SSC_DEPTH_2M;
836836 chip->ssc_depth_sd_sdr50 = SSC_DEPTH_2M;
drivers/staging/rts_pstor/rtsx_chip.c+5−6
@@ -684,6 +684,11 @@ static int rts5209_init(struct rtsx_chip *chip) · 683 unmodified lines
684684 RTSX_DEBUGP("dw in 0x724: 0x%x\n", lval);
685685 val = (u8)lval;
686686 if (!(val & 0x80)) {
687+ if (val & 0x08)
688+ chip->lun_mode = DEFAULT_SINGLE;
689+ else
690+ chip->lun_mode = SD_MS_2LUN;
691+
687692 if (val & 0x04) {
688693 SET_SDIO_EXIST(chip);
689694 } else {
@@ -705,12 +710,6 @@ static int rts5209_init(struct rtsx_chip *chip) · 15 unmodified lines
705710
706711 chip->aspm_l0s_l1_en = (val >> 5) & 0x03;
707712
708− if (val & 0x08) {
709− chip->lun_mode = DEFAULT_SINGLE;
710− } else {
711− chip->lun_mode = SD_MS_2LUN;
712− }
713−
714713 val = (u8)(lval >> 8);
715714
716715 clk = (val >> 5) & 0x07;
drivers/staging/sep/sep_driver.c+2−13
@@ -55,8 +55,6 @@ · 54 unmodified lines
5555 #include <linux/jiffies.h>
5656 #include <linux/rar_register.h>
5757
58−#include "../memrar/memrar.h"
59−
6058 #include "sep_driver_hw_defs.h"
6159 #include "sep_driver_config.h"
6260 #include "sep_driver_api.h"
@@ -2372,7 +2370,6 @@ static int sep_rar_prepare_output_msg_handler(struct sep_device *sep, · 2309 unmodified lines
23722370 int error = 0;
23732371 /* Command args */
23742372 struct rar_hndl_to_bus_struct command_args;
2375− struct RAR_buffer rar_buf;
23762373 /* Bus address */
23772374 dma_addr_t rar_bus = 0;
23782375 /* Holds the RAR address in the system memory offset */
@@ -2386,16 +2383,8 @@ static int sep_rar_prepare_output_msg_handler(struct sep_device *sep, · 7 unmodified lines
23862383 }
23872384
23882385 /* Call to translation function only if user handle is not NULL */
2389− if (command_args.rar_handle) {
2390− memset(&rar_buf, 0, sizeof(rar_buf));
2391− rar_buf.info.handle = (u32)command_args.rar_handle;
2392−
2393− if (rar_handle_to_bus(&rar_buf, 1) != 1) {
2394− error = -EFAULT;
2395− goto end_function;
2396− }
2397− rar_bus = rar_buf.bus_address;
2398− }
2386+ if (command_args.rar_handle)
2387+ return -EOPNOTSUPP;
23992388 dev_dbg(&sep->pdev->dev, "rar msg; rar_addr_bus = %x\n", (u32)rar_bus);
24002389
24012390 /* Set value in the SYSTEM MEMORY offset */
drivers/staging/sm7xx/smtcfb.c+2−4
@@ -26,10 +26,6 @@ · 25 unmodified lines
2626 * Boyod.yang <boyod.yang@siliconmotion.com.cn>
2727 */
2828
29−#ifndef __KERNEL__
30−#define __KERNEL__
31−#endif
32−
3329 #include <linux/io.h>
3430 #include <linux/fb.h>
3531 #include <linux/pci.h>
@@ -1019,6 +1015,7 @@ static void __devexit smtcfb_pci_remove(struct pci_dev *pdev) · 983 unmodified lines
10191015 smtc_free_fb_info(sfb);
10201016 }
10211017
1018+#ifdef CONFIG_PM
10221019 /* Jason (08/14/2009)
10231020 * suspend function, called when the suspend event is triggered
10241021 */
@@ -1111,6 +1108,7 @@ static int __maybe_unused smtcfb_resume(struct pci_dev *pdev) · 86 unmodified lines
11111108
11121109 return 0;
11131110 }
1111+#endif
11141112
11151113 /* Jason (08/13/2009)
11161114 * pci_driver struct used to wrap the original driver
drivers/staging/usbip/stub_dev.c+4−2
@@ -220,8 +220,10 @@ static void stub_shutdown_connection(struct usbip_device *ud) · 219 unmodified lines
220220 }
221221
222222 /* 1. stop threads */
223− kthread_stop(ud->tcp_rx);
224− kthread_stop(ud->tcp_tx);
223+ if (ud->tcp_rx && !task_is_dead(ud->tcp_rx))
224+ kthread_stop(ud->tcp_rx);
225+ if (ud->tcp_tx && !task_is_dead(ud->tcp_tx))
226+ kthread_stop(ud->tcp_tx);
225227
226228 /* 2. close the socket */
227229 /*
drivers/staging/usbip/stub_rx.c+15−25
@@ -171,33 +171,23 @@ static int tweak_set_configuration_cmd(struct urb *urb) · 170 unmodified lines
171171
172172 static int tweak_reset_device_cmd(struct urb *urb)
173173 {
174− struct usb_ctrlrequest *req;
175− __u16 value;
176− __u16 index;
177− int ret;
178−
179− req = (struct usb_ctrlrequest *) urb->setup_packet;
180− value = le16_to_cpu(req->wValue);
181− index = le16_to_cpu(req->wIndex);
182−
183− usbip_uinfo("reset_device (port %d) to %s\n", index,
184− dev_name(&urb->dev->dev));
174+ struct stub_priv *priv = (struct stub_priv *) urb->context;
175+ struct stub_device *sdev = priv->sdev;
185176
186− /* all interfaces should be owned by usbip driver, so just reset it. */
187− ret = usb_lock_device_for_reset(urb->dev, NULL);
188− if (ret < 0) {
189− dev_err(&urb->dev->dev, "lock for reset\n");
190− return ret;
191− }
192−
193− /* try to reset the device */
194− ret = usb_reset_device(urb->dev);
195− if (ret < 0)
196− dev_err(&urb->dev->dev, "device reset\n");
177+ usbip_uinfo("reset_device %s\n", dev_name(&urb->dev->dev));
197178
198− usb_unlock_device(urb->dev);
199−
200− return ret;
179+ /*
180+ * usb_lock_device_for_reset caused a deadlock: it causes the driver
181+ * to unbind. In the shutdown the rx thread is signalled to shut down
182+ * but this thread is pending in the usb_lock_device_for_reset.
183+ *
184+ * Instead queue the reset.
185+ *
186+ * Unfortunatly an existing usbip connection will be dropped due to
187+ * driver unbinding.
188+ */
189+ usb_queue_reset_device(sdev->interface);
190+ return 0;
201191 }
202192
203193 /*
drivers/staging/usbip/stub_tx.c+60−14
@@ -170,7 +170,6 @@ static int stub_send_ret_submit(struct stub_device *sdev) · 169 unmodified lines
170170 struct stub_priv *priv, *tmp;
171171
172172 struct msghdr msg;
173− struct kvec iov[3];
174173 size_t txsize;
175174
176175 size_t total_size = 0;
@@ -180,28 +179,73 @@ static int stub_send_ret_submit(struct stub_device *sdev) · 3 unmodified lines
180179 struct urb *urb = priv->urb;
181180 struct usbip_header pdu_header;
182181 void *iso_buffer = NULL;
182+ struct kvec *iov = NULL;
183+ int iovnum = 0;
183184
184185 txsize = 0;
185186 memset(&pdu_header, 0, sizeof(pdu_header));
186187 memset(&msg, 0, sizeof(msg));
187− memset(&iov, 0, sizeof(iov));
188188
189− usbip_dbg_stub_tx("setup txdata urb %p\n", urb);
189+ if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS)
190+ iovnum = 2 + urb->number_of_packets;
191+ else
192+ iovnum = 2;
193+
194+ iov = kzalloc(iovnum * sizeof(struct kvec), GFP_KERNEL);
190195
196+ if (!iov) {
197+ usbip_event_add(&sdev->ud, SDEV_EVENT_ERROR_MALLOC);
198+ return -1;
199+ }
200+
201+ iovnum = 0;
191202
192203 /* 1. setup usbip_header */
193204 setup_ret_submit_pdu(&pdu_header, urb);
205+ usbip_dbg_stub_tx("setup txdata seqnum: %d urb: %p\n",
206+ pdu_header.base.seqnum, urb);
207+ /*usbip_dump_header(pdu_header);*/
194208 usbip_header_correct_endian(&pdu_header, 1);
195209
196− iov[0].iov_base = &pdu_header;
197− iov[0].iov_len = sizeof(pdu_header);
210+ iov[iovnum].iov_base = &pdu_header;
211+ iov[iovnum].iov_len = sizeof(pdu_header);
212+ iovnum++;
198213 txsize += sizeof(pdu_header);
199214
200215 /* 2. setup transfer buffer */
201− if (usb_pipein(urb->pipe) && urb->actual_length > 0) {
202− iov[1].iov_base = urb->transfer_buffer;
203− iov[1].iov_len = urb->actual_length;
216+ if (usb_pipein(urb->pipe) &&
217+ usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS &&
218+ urb->actual_length > 0) {
219+ iov[iovnum].iov_base = urb->transfer_buffer;
220+ iov[iovnum].iov_len = urb->actual_length;
221+ iovnum++;
204222 txsize += urb->actual_length;
223+ } else if (usb_pipein(urb->pipe) &&
224+ usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
225+ /*
226+ * For isochronous packets: actual length is the sum of
227+ * the actual length of the individual, packets, but as
228+ * the packet offsets are not changed there will be
229+ * padding between the packets. To optimally use the
230+ * bandwidth the padding is not transmitted.
231+ */
232+
233+ int i;
234+ for (i = 0; i < urb->number_of_packets; i++) {
235+ iov[iovnum].iov_base = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
236+ iov[iovnum].iov_len = urb->iso_frame_desc[i].actual_length;
237+ iovnum++;
238+ txsize += urb->iso_frame_desc[i].actual_length;
239+ }
240+
241+ if (txsize != sizeof(pdu_header) + urb->actual_length) {
242+ dev_err(&sdev->interface->dev,
243+ "actual length of urb (%d) does not match iso packet sizes (%d)\n",
244+ urb->actual_length, txsize-sizeof(pdu_header));
245+ kfree(iov);
246+ usbip_event_add(&sdev->ud, SDEV_EVENT_ERROR_TCP);
247+ return -1;
248+ }
205249 }
206250
207251 /* 3. setup iso_packet_descriptor */
@@ -212,32 +256,34 @@ static int stub_send_ret_submit(struct stub_device *sdev) · 4 unmodified lines
212256 if (!iso_buffer) {
213257 usbip_event_add(&sdev->ud,
214258 SDEV_EVENT_ERROR_MALLOC);
259+ kfree(iov);
215260 return -1;
216261 }
217262
218− iov[2].iov_base = iso_buffer;
219− iov[2].iov_len = len;
263+ iov[iovnum].iov_base = iso_buffer;
264+ iov[iovnum].iov_len = len;
220265 txsize += len;
266+ iovnum++;
221267 }
222268
223− ret = kernel_sendmsg(sdev->ud.tcp_socket, &msg, iov,
224− 3, txsize);
269+ ret = kernel_sendmsg(sdev->ud.tcp_socket, &msg,
270+ iov, iovnum, txsize);
225271 if (ret != txsize) {
226272 dev_err(&sdev->interface->dev,
227273 "sendmsg failed!, retval %d for %zd\n",
228274 ret, txsize);
275+ kfree(iov);
229276 kfree(iso_buffer);
230277 usbip_event_add(&sdev->ud, SDEV_EVENT_ERROR_TCP);
231278 return -1;
232279 }
233280
281+ kfree(iov);
234282 kfree(iso_buffer);
235− usbip_dbg_stub_tx("send txdata\n");
236283
237284 total_size += txsize;
238285 }
239286
240−
241287 spin_lock_irqsave(&sdev->priv_lock, flags);
242288
243289 list_for_each_entry_safe(priv, tmp, &sdev->priv_free, list) {
drivers/staging/usbip/usbip_common.c+63−1
@@ -333,10 +333,11 @@ void usbip_dump_header(struct usbip_header *pdu) · 332 unmodified lines
333333 usbip_udbg("CMD_UNLINK: seq %u\n", pdu->u.cmd_unlink.seqnum);
334334 break;
335335 case USBIP_RET_SUBMIT:
336− usbip_udbg("RET_SUBMIT: st %d al %u sf %d ec %d\n",
336+ usbip_udbg("RET_SUBMIT: st %d al %u sf %d #p %d ec %d\n",
337337 pdu->u.ret_submit.status,
338338 pdu->u.ret_submit.actual_length,
339339 pdu->u.ret_submit.start_frame,
340+ pdu->u.ret_submit.number_of_packets,
340341 pdu->u.ret_submit.error_count);
341342 case USBIP_RET_UNLINK:
342343 usbip_udbg("RET_UNLINK: status %d\n", pdu->u.ret_unlink.status);
@@ -520,6 +521,7 @@ static void usbip_pack_ret_submit(struct usbip_header *pdu, struct urb *urb, · 177 unmodified lines
520521 rpdu->status = urb->status;
521522 rpdu->actual_length = urb->actual_length;
522523 rpdu->start_frame = urb->start_frame;
524+ rpdu->number_of_packets = urb->number_of_packets;
523525 rpdu->error_count = urb->error_count;
524526 } else {
525527 /* vhci_rx.c */
@@ -527,6 +529,7 @@ static void usbip_pack_ret_submit(struct usbip_header *pdu, struct urb *urb, · 1 unmodified line
527529 urb->status = rpdu->status;
528530 urb->actual_length = rpdu->actual_length;
529531 urb->start_frame = rpdu->start_frame;
532+ urb->number_of_packets = rpdu->number_of_packets;
530533 urb->error_count = rpdu->error_count;
531534 }
532535 }
@@ -595,11 +598,13 @@ static void correct_endian_ret_submit(struct usbip_header_ret_submit *pdu, · 62 unmodified lines
595598 cpu_to_be32s(&pdu->status);
596599 cpu_to_be32s(&pdu->actual_length);
597600 cpu_to_be32s(&pdu->start_frame);
601+ cpu_to_be32s(&pdu->number_of_packets);
598602 cpu_to_be32s(&pdu->error_count);
599603 } else {
600604 be32_to_cpus(&pdu->status);
601605 be32_to_cpus(&pdu->actual_length);
602606 be32_to_cpus(&pdu->start_frame);
607+ cpu_to_be32s(&pdu->number_of_packets);
603608 be32_to_cpus(&pdu->error_count);
604609 }
605610 }
@@ -725,6 +730,7 @@ int usbip_recv_iso(struct usbip_device *ud, struct urb *urb) · 119 unmodified lines
725730 int size = np * sizeof(*iso);
726731 int i;
727732 int ret;
733+ int total_length = 0;
728734
729735 if (!usb_pipeisoc(urb->pipe))
730736 return 0;
@@ -754,19 +760,75 @@ int usbip_recv_iso(struct usbip_device *ud, struct urb *urb) · 23 unmodified lines
754760 return -EPIPE;
755761 }
756762
763+
757764 for (i = 0; i < np; i++) {
758765 iso = buff + (i * sizeof(*iso));
759766
760767 usbip_iso_pakcet_correct_endian(iso, 0);
761768 usbip_pack_iso(iso, &urb->iso_frame_desc[i], 0);
769+ total_length += urb->iso_frame_desc[i].actual_length;
762770 }
763771
764772 kfree(buff);
765773
774+ if (total_length != urb->actual_length) {
775+ dev_err(&urb->dev->dev,
776+ "total length of iso packets (%d) not equal to actual length of buffer (%d)\n",
777+ total_length, urb->actual_length);
778+
779+ if (ud->side == USBIP_STUB)
780+ usbip_event_add(ud, SDEV_EVENT_ERROR_TCP);
781+ else
782+ usbip_event_add(ud, VDEV_EVENT_ERROR_TCP);
783+
784+ return -EPIPE;
785+ }
786+
766787 return ret;
767788 }
768789 EXPORT_SYMBOL_GPL(usbip_recv_iso);
769790
791+/*
792+ * This functions restores the padding which was removed for optimizing
793+ * the bandwidth during transfer over tcp/ip
794+ *
795+ * buffer and iso packets need to be stored and be in propeper endian in urb
796+ * before calling this function
797+ */
798+int usbip_pad_iso(struct usbip_device *ud, struct urb *urb)
799+{
800+ int np = urb->number_of_packets;
801+ int i;
802+ int ret;
803+ int actualoffset = urb->actual_length;
804+
805+ if (!usb_pipeisoc(urb->pipe))
806+ return 0;
807+
808+ /* if no packets or length of data is 0, then nothing to unpack */
809+ if (np == 0 || urb->actual_length == 0)
810+ return 0;
811+
812+ /*
813+ * if actual_length is transfer_buffer_length then no padding is
814+ * present.
815+ */
816+ if (urb->actual_length == urb->transfer_buffer_length)
817+ return 0;
818+
819+ /*
820+ * loop over all packets from last to first (to prevent overwritting
821+ * memory when padding) and move them into the proper place
822+ */
823+ for (i = np-1; i > 0; i--) {
824+ actualoffset -= urb->iso_frame_desc[i].actual_length;
825+ memmove(urb->transfer_buffer + urb->iso_frame_desc[i].offset,
826+ urb->transfer_buffer + actualoffset,
827+ urb->iso_frame_desc[i].actual_length);
828+ }
829+ return ret;
830+}
831+EXPORT_SYMBOL_GPL(usbip_pad_iso);
770832
771833 /* some members of urb must be substituted before. */
772834 int usbip_recv_xbuff(struct usbip_device *ud, struct urb *urb)
drivers/staging/usbip/usbip_common.h+2−0
@@ -379,6 +379,8 @@ void usbip_header_correct_endian(struct usbip_header *pdu, int send); · 378 unmodified lines
379379 int usbip_recv_xbuff(struct usbip_device *ud, struct urb *urb);
380380 /* some members of urb must be substituted before. */
381381 int usbip_recv_iso(struct usbip_device *ud, struct urb *urb);
382+/* some members of urb must be substituted before. */
383+int usbip_pad_iso(struct usbip_device *ud, struct urb *urb);
382384 void *usbip_alloc_iso_desc_pdu(struct urb *urb, ssize_t *bufflen);
383385
384386
drivers/staging/usbip/vhci_rx.c+3−0
@@ -100,6 +100,9 @@ static void vhci_recv_ret_submit(struct vhci_device *vdev, · 99 unmodified lines
100100 if (usbip_recv_iso(ud, urb) < 0)
101101 return;
102102
103+ /* restore the padding in iso packets */
104+ if (usbip_pad_iso(ud, urb) < 0)
105+ return;
103106
104107 if (usbip_dbg_flag_vhci_rx)
105108 usbip_dump_urb(urb);
drivers/staging/vt6655/Kconfig+1−1
@@ -1,6 +1,6 @@
11 config VT6655
22 tristate "VIA Technologies VT6655 support"
3− depends on PCI && WLAN
3+ depends on PCI && WLAN && m
44 select WIRELESS_EXT
55 select WEXT_PRIV
66 ---help---
drivers/staging/vt6656/Kconfig+1−1
@@ -1,6 +1,6 @@
11 config VT6656
22 tristate "VIA Technologies VT6656 support"
3− depends on USB && WLAN
3+ depends on USB && WLAN && m
44 select WIRELESS_EXT
55 select WEXT_PRIV
66 select FW_LOADER
drivers/staging/westbridge/astoria/gadget/cyasgadget.c+1−0
@@ -587,6 +587,7 @@ static int cyasgadget_enable( · 586 unmodified lines
587587 "cy_as_usb_end_point_config EP %s mismatch "
588588 "on enabled\n", an_ep->usb_ep_inst.name);
589589 #endif
590+ spin_unlock_irqrestore(&an_dev->lock, flags);
590591 return -EINVAL;
591592 }
592593

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t